21784 lines
798 KiB
TypeScript
21784 lines
798 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 Admin
|
|
*
|
|
*/
|
|
export type Admin = $Result.DefaultSelection<Prisma.$AdminPayload>
|
|
/**
|
|
* Model User
|
|
*
|
|
*/
|
|
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
|
|
/**
|
|
* Model OtpCode
|
|
*
|
|
*/
|
|
export type OtpCode = $Result.DefaultSelection<Prisma.$OtpCodePayload>
|
|
/**
|
|
* Model Campaign
|
|
*
|
|
*/
|
|
export type Campaign = $Result.DefaultSelection<Prisma.$CampaignPayload>
|
|
/**
|
|
* Model Prize
|
|
*
|
|
*/
|
|
export type Prize = $Result.DefaultSelection<Prisma.$PrizePayload>
|
|
/**
|
|
* Model UserCampaign
|
|
*
|
|
*/
|
|
export type UserCampaign = $Result.DefaultSelection<Prisma.$UserCampaignPayload>
|
|
/**
|
|
* Model ChanceTransaction
|
|
*
|
|
*/
|
|
export type ChanceTransaction = $Result.DefaultSelection<Prisma.$ChanceTransactionPayload>
|
|
/**
|
|
* Model Spin
|
|
*
|
|
*/
|
|
export type Spin = $Result.DefaultSelection<Prisma.$SpinPayload>
|
|
/**
|
|
* Model UserPrize
|
|
*
|
|
*/
|
|
export type UserPrize = $Result.DefaultSelection<Prisma.$UserPrizePayload>
|
|
/**
|
|
* Model SmsLog
|
|
*
|
|
*/
|
|
export type SmsLog = $Result.DefaultSelection<Prisma.$SmsLogPayload>
|
|
/**
|
|
* Model AdminLog
|
|
*
|
|
*/
|
|
export type AdminLog = $Result.DefaultSelection<Prisma.$AdminLogPayload>
|
|
|
|
/**
|
|
* Enums
|
|
*/
|
|
export namespace $Enums {
|
|
export const AdminRole: {
|
|
SUPER_ADMIN: 'SUPER_ADMIN',
|
|
OPERATOR: 'OPERATOR',
|
|
SUPPORT: 'SUPPORT'
|
|
};
|
|
|
|
export type AdminRole = (typeof AdminRole)[keyof typeof AdminRole]
|
|
|
|
|
|
export const AdminStatus: {
|
|
ACTIVE: 'ACTIVE',
|
|
DISABLED: 'DISABLED'
|
|
};
|
|
|
|
export type AdminStatus = (typeof AdminStatus)[keyof typeof AdminStatus]
|
|
|
|
|
|
export const UserStatus: {
|
|
ACTIVE: 'ACTIVE',
|
|
BLOCKED: 'BLOCKED'
|
|
};
|
|
|
|
export type UserStatus = (typeof UserStatus)[keyof typeof UserStatus]
|
|
|
|
|
|
export const CampaignStatus: {
|
|
DRAFT: 'DRAFT',
|
|
ACTIVE: 'ACTIVE',
|
|
PAUSED: 'PAUSED',
|
|
FINISHED: 'FINISHED'
|
|
};
|
|
|
|
export type CampaignStatus = (typeof CampaignStatus)[keyof typeof CampaignStatus]
|
|
|
|
|
|
export const WheelDesign: {
|
|
CLASSIC_CASINO: 'CLASSIC_CASINO',
|
|
NEON_CYBER: 'NEON_CYBER',
|
|
MINIMAL_FLAT: 'MINIMAL_FLAT',
|
|
LUXURY_GOLD: 'LUXURY_GOLD',
|
|
PLAYFUL_CARTOON: 'PLAYFUL_CARTOON'
|
|
};
|
|
|
|
export type WheelDesign = (typeof WheelDesign)[keyof typeof WheelDesign]
|
|
|
|
|
|
export const PrizeType: {
|
|
PHYSICAL: 'PHYSICAL',
|
|
DISCOUNT_CODE: 'DISCOUNT_CODE',
|
|
CREDIT: 'CREDIT',
|
|
CASH: 'CASH',
|
|
NO_PRIZE: 'NO_PRIZE',
|
|
OTHER: 'OTHER'
|
|
};
|
|
|
|
export type PrizeType = (typeof PrizeType)[keyof typeof PrizeType]
|
|
|
|
|
|
export const StockType: {
|
|
LIMITED: 'LIMITED',
|
|
UNLIMITED: 'UNLIMITED'
|
|
};
|
|
|
|
export type StockType = (typeof StockType)[keyof typeof StockType]
|
|
|
|
|
|
export const PrizeStatus: {
|
|
ACTIVE: 'ACTIVE',
|
|
INACTIVE: 'INACTIVE'
|
|
};
|
|
|
|
export type PrizeStatus = (typeof PrizeStatus)[keyof typeof PrizeStatus]
|
|
|
|
|
|
export const ChanceTxnType: {
|
|
SIGNUP_BONUS: 'SIGNUP_BONUS',
|
|
ADMIN_ADJUSTMENT: 'ADMIN_ADJUSTMENT',
|
|
SPIN_CONSUME: 'SPIN_CONSUME',
|
|
CAMPAIGN_BONUS: 'CAMPAIGN_BONUS',
|
|
REFUND: 'REFUND'
|
|
};
|
|
|
|
export type ChanceTxnType = (typeof ChanceTxnType)[keyof typeof ChanceTxnType]
|
|
|
|
|
|
export const SpinStatus: {
|
|
SUCCESS: 'SUCCESS',
|
|
FAILED: 'FAILED',
|
|
DUPLICATE: 'DUPLICATE'
|
|
};
|
|
|
|
export type SpinStatus = (typeof SpinStatus)[keyof typeof SpinStatus]
|
|
|
|
|
|
export const UserPrizeStatus: {
|
|
NEW: 'NEW',
|
|
CONTACTED: 'CONTACTED',
|
|
DELIVERED: 'DELIVERED',
|
|
ACTIVE_CODE: 'ACTIVE_CODE',
|
|
USED: 'USED',
|
|
EXPIRED: 'EXPIRED'
|
|
};
|
|
|
|
export type UserPrizeStatus = (typeof UserPrizeStatus)[keyof typeof UserPrizeStatus]
|
|
|
|
|
|
export const SmsType: {
|
|
OTP: 'OTP',
|
|
WINNING: 'WINNING',
|
|
NO_PRIZE: 'NO_PRIZE',
|
|
PRIZE_REMINDER: 'PRIZE_REMINDER'
|
|
};
|
|
|
|
export type SmsType = (typeof SmsType)[keyof typeof SmsType]
|
|
|
|
|
|
export const SmsStatus: {
|
|
PENDING: 'PENDING',
|
|
SENT: 'SENT',
|
|
FAILED: 'FAILED'
|
|
};
|
|
|
|
export type SmsStatus = (typeof SmsStatus)[keyof typeof SmsStatus]
|
|
|
|
}
|
|
|
|
export type AdminRole = $Enums.AdminRole
|
|
|
|
export const AdminRole: typeof $Enums.AdminRole
|
|
|
|
export type AdminStatus = $Enums.AdminStatus
|
|
|
|
export const AdminStatus: typeof $Enums.AdminStatus
|
|
|
|
export type UserStatus = $Enums.UserStatus
|
|
|
|
export const UserStatus: typeof $Enums.UserStatus
|
|
|
|
export type CampaignStatus = $Enums.CampaignStatus
|
|
|
|
export const CampaignStatus: typeof $Enums.CampaignStatus
|
|
|
|
export type WheelDesign = $Enums.WheelDesign
|
|
|
|
export const WheelDesign: typeof $Enums.WheelDesign
|
|
|
|
export type PrizeType = $Enums.PrizeType
|
|
|
|
export const PrizeType: typeof $Enums.PrizeType
|
|
|
|
export type StockType = $Enums.StockType
|
|
|
|
export const StockType: typeof $Enums.StockType
|
|
|
|
export type PrizeStatus = $Enums.PrizeStatus
|
|
|
|
export const PrizeStatus: typeof $Enums.PrizeStatus
|
|
|
|
export type ChanceTxnType = $Enums.ChanceTxnType
|
|
|
|
export const ChanceTxnType: typeof $Enums.ChanceTxnType
|
|
|
|
export type SpinStatus = $Enums.SpinStatus
|
|
|
|
export const SpinStatus: typeof $Enums.SpinStatus
|
|
|
|
export type UserPrizeStatus = $Enums.UserPrizeStatus
|
|
|
|
export const UserPrizeStatus: typeof $Enums.UserPrizeStatus
|
|
|
|
export type SmsType = $Enums.SmsType
|
|
|
|
export const SmsType: typeof $Enums.SmsType
|
|
|
|
export type SmsStatus = $Enums.SmsStatus
|
|
|
|
export const SmsStatus: typeof $Enums.SmsStatus
|
|
|
|
/**
|
|
* ## Prisma Client ʲˢ
|
|
*
|
|
* Type-safe database client for TypeScript & Node.js
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient()
|
|
* // Fetch zero or more Admins
|
|
* const admins = await prisma.admin.findMany()
|
|
* ```
|
|
*
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
|
|
*/
|
|
export class PrismaClient<
|
|
ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
|
|
U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
|
|
ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
|
|
> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
|
|
|
|
/**
|
|
* ## Prisma Client ʲˢ
|
|
*
|
|
* Type-safe database client for TypeScript & Node.js
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient()
|
|
* // Fetch zero or more Admins
|
|
* const admins = await prisma.admin.findMany()
|
|
* ```
|
|
*
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
|
|
*/
|
|
|
|
constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
|
|
$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void;
|
|
|
|
/**
|
|
* Connect with the database
|
|
*/
|
|
$connect(): $Utils.JsPromise<void>;
|
|
|
|
/**
|
|
* Disconnect from the database
|
|
*/
|
|
$disconnect(): $Utils.JsPromise<void>;
|
|
|
|
/**
|
|
* Add a middleware
|
|
* @deprecated since 4.16.0. For new code, prefer client extensions instead.
|
|
* @see https://pris.ly/d/extensions
|
|
*/
|
|
$use(cb: Prisma.Middleware): void
|
|
|
|
/**
|
|
* Executes a prepared raw query and returns the number of affected rows.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
|
|
|
|
/**
|
|
* Executes a raw query and returns the number of affected rows.
|
|
* Susceptible to SQL injections, see documentation.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
|
|
|
|
/**
|
|
* Performs a prepared raw query and returns the `SELECT` data.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
|
|
|
|
/**
|
|
* Performs a raw query and returns the `SELECT` data.
|
|
* Susceptible to SQL injections, see documentation.
|
|
* @example
|
|
* ```
|
|
* const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
|
|
*/
|
|
$queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
|
|
|
|
|
|
/**
|
|
* Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
|
|
* @example
|
|
* ```
|
|
* const [george, bob, alice] = await prisma.$transaction([
|
|
* prisma.user.create({ data: { name: 'George' } }),
|
|
* prisma.user.create({ data: { name: 'Bob' } }),
|
|
* prisma.user.create({ data: { name: 'Alice' } }),
|
|
* ])
|
|
* ```
|
|
*
|
|
* Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
|
|
*/
|
|
$transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>
|
|
|
|
$transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => $Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<R>
|
|
|
|
|
|
$extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs>
|
|
|
|
/**
|
|
* `prisma.admin`: Exposes CRUD operations for the **Admin** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Admins
|
|
* const admins = await prisma.admin.findMany()
|
|
* ```
|
|
*/
|
|
get admin(): Prisma.AdminDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.user`: Exposes CRUD operations for the **User** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Users
|
|
* const users = await prisma.user.findMany()
|
|
* ```
|
|
*/
|
|
get user(): Prisma.UserDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.otpCode`: Exposes CRUD operations for the **OtpCode** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more OtpCodes
|
|
* const otpCodes = await prisma.otpCode.findMany()
|
|
* ```
|
|
*/
|
|
get otpCode(): Prisma.OtpCodeDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.campaign`: Exposes CRUD operations for the **Campaign** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Campaigns
|
|
* const campaigns = await prisma.campaign.findMany()
|
|
* ```
|
|
*/
|
|
get campaign(): Prisma.CampaignDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.prize`: Exposes CRUD operations for the **Prize** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Prizes
|
|
* const prizes = await prisma.prize.findMany()
|
|
* ```
|
|
*/
|
|
get prize(): Prisma.PrizeDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.userCampaign`: Exposes CRUD operations for the **UserCampaign** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more UserCampaigns
|
|
* const userCampaigns = await prisma.userCampaign.findMany()
|
|
* ```
|
|
*/
|
|
get userCampaign(): Prisma.UserCampaignDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.chanceTransaction`: Exposes CRUD operations for the **ChanceTransaction** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more ChanceTransactions
|
|
* const chanceTransactions = await prisma.chanceTransaction.findMany()
|
|
* ```
|
|
*/
|
|
get chanceTransaction(): Prisma.ChanceTransactionDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.spin`: Exposes CRUD operations for the **Spin** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Spins
|
|
* const spins = await prisma.spin.findMany()
|
|
* ```
|
|
*/
|
|
get spin(): Prisma.SpinDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.userPrize`: Exposes CRUD operations for the **UserPrize** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more UserPrizes
|
|
* const userPrizes = await prisma.userPrize.findMany()
|
|
* ```
|
|
*/
|
|
get userPrize(): Prisma.UserPrizeDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.smsLog`: Exposes CRUD operations for the **SmsLog** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more SmsLogs
|
|
* const smsLogs = await prisma.smsLog.findMany()
|
|
* ```
|
|
*/
|
|
get smsLog(): Prisma.SmsLogDelegate<ExtArgs>;
|
|
|
|
/**
|
|
* `prisma.adminLog`: Exposes CRUD operations for the **AdminLog** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more AdminLogs
|
|
* const adminLogs = await prisma.adminLog.findMany()
|
|
* ```
|
|
*/
|
|
get adminLog(): Prisma.AdminLogDelegate<ExtArgs>;
|
|
}
|
|
|
|
export namespace Prisma {
|
|
export import DMMF = runtime.DMMF
|
|
|
|
export type PrismaPromise<T> = $Public.PrismaPromise<T>
|
|
|
|
/**
|
|
* Validator
|
|
*/
|
|
export import validator = runtime.Public.validator
|
|
|
|
/**
|
|
* Prisma Errors
|
|
*/
|
|
export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
|
|
export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
|
|
export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
|
|
export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
|
|
export import PrismaClientValidationError = runtime.PrismaClientValidationError
|
|
export import NotFoundError = runtime.NotFoundError
|
|
|
|
/**
|
|
* Re-export of sql-template-tag
|
|
*/
|
|
export import sql = runtime.sqltag
|
|
export import empty = runtime.empty
|
|
export import join = runtime.join
|
|
export import raw = runtime.raw
|
|
export import Sql = runtime.Sql
|
|
|
|
|
|
|
|
/**
|
|
* Decimal.js
|
|
*/
|
|
export import Decimal = runtime.Decimal
|
|
|
|
export type DecimalJsLike = runtime.DecimalJsLike
|
|
|
|
/**
|
|
* Metrics
|
|
*/
|
|
export type Metrics = runtime.Metrics
|
|
export type Metric<T> = runtime.Metric<T>
|
|
export type MetricHistogram = runtime.MetricHistogram
|
|
export type MetricHistogramBucket = runtime.MetricHistogramBucket
|
|
|
|
/**
|
|
* Extensions
|
|
*/
|
|
export import Extension = $Extensions.UserArgs
|
|
export import getExtensionContext = runtime.Extensions.getExtensionContext
|
|
export import Args = $Public.Args
|
|
export import Payload = $Public.Payload
|
|
export import Result = $Public.Result
|
|
export import Exact = $Public.Exact
|
|
|
|
/**
|
|
* Prisma Client JS version: 5.22.0
|
|
* Query Engine version: 605197351a3c8bdd595af2d2a9bc3025bca48ea2
|
|
*/
|
|
export type PrismaVersion = {
|
|
client: string
|
|
}
|
|
|
|
export const prismaVersion: PrismaVersion
|
|
|
|
/**
|
|
* Utility Types
|
|
*/
|
|
|
|
|
|
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 ? K : never]-?: O[P]} & O
|
|
: never>;
|
|
|
|
type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
|
|
|
|
export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
|
|
/** End Helper Types for "Merge" **/
|
|
|
|
export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
|
|
|
|
/**
|
|
A [[Boolean]]
|
|
*/
|
|
export type Boolean = True | False
|
|
|
|
// /**
|
|
// 1
|
|
// */
|
|
export type True = 1
|
|
|
|
/**
|
|
0
|
|
*/
|
|
export type False = 0
|
|
|
|
export type Not<B extends Boolean> = {
|
|
0: 1
|
|
1: 0
|
|
}[B]
|
|
|
|
export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
|
|
? 0 // anything `never` is false
|
|
: A1 extends A2
|
|
? 1
|
|
: 0
|
|
|
|
export type Has<U extends Union, U1 extends Union> = Not<
|
|
Extends<Exclude<U1, U>, U1>
|
|
>
|
|
|
|
export type Or<B1 extends Boolean, B2 extends Boolean> = {
|
|
0: {
|
|
0: 0
|
|
1: 1
|
|
}
|
|
1: {
|
|
0: 1
|
|
1: 1
|
|
}
|
|
}[B1][B2]
|
|
|
|
export type Keys<U extends Union> = U extends unknown ? keyof U : never
|
|
|
|
type Cast<A, B> = A extends B ? A : B;
|
|
|
|
export const type: unique symbol;
|
|
|
|
|
|
|
|
/**
|
|
* Used by group by
|
|
*/
|
|
|
|
export type GetScalarType<T, O> = O extends object ? {
|
|
[P in keyof T]: P extends keyof O
|
|
? O[P]
|
|
: never
|
|
} : never
|
|
|
|
type FieldPaths<
|
|
T,
|
|
U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
|
|
> = IsObject<T> extends True ? U : T
|
|
|
|
type GetHavingFields<T> = {
|
|
[K in keyof T]: Or<
|
|
Or<Extends<'OR', K>, Extends<'AND', K>>,
|
|
Extends<'NOT', K>
|
|
> extends True
|
|
? // infer is only needed to not hit TS limit
|
|
// based on the brilliant idea of Pierre-Antoine Mills
|
|
// https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
|
|
T[K] extends infer TK
|
|
? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
|
|
: never
|
|
: {} extends FieldPaths<T[K]>
|
|
? never
|
|
: K
|
|
}[keyof T]
|
|
|
|
/**
|
|
* Convert tuple to union
|
|
*/
|
|
type _TupleToUnion<T> = T extends (infer E)[] ? E : never
|
|
type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
|
|
type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
|
|
|
|
/**
|
|
* Like `Pick`, but additionally can also accept an array of keys
|
|
*/
|
|
type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
|
|
|
|
/**
|
|
* Exclude all keys with underscores
|
|
*/
|
|
type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T
|
|
|
|
|
|
export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
|
|
|
|
type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
|
|
|
|
|
|
export const ModelName: {
|
|
Admin: 'Admin',
|
|
User: 'User',
|
|
OtpCode: 'OtpCode',
|
|
Campaign: 'Campaign',
|
|
Prize: 'Prize',
|
|
UserCampaign: 'UserCampaign',
|
|
ChanceTransaction: 'ChanceTransaction',
|
|
Spin: 'Spin',
|
|
UserPrize: 'UserPrize',
|
|
SmsLog: 'SmsLog',
|
|
AdminLog: 'AdminLog'
|
|
};
|
|
|
|
export type ModelName = (typeof ModelName)[keyof typeof ModelName]
|
|
|
|
|
|
export type Datasources = {
|
|
db?: Datasource
|
|
}
|
|
|
|
interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record<string, any>> {
|
|
returns: Prisma.TypeMap<this['params']['extArgs'], this['params']['clientOptions']>
|
|
}
|
|
|
|
export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
|
|
meta: {
|
|
modelProps: "admin" | "user" | "otpCode" | "campaign" | "prize" | "userCampaign" | "chanceTransaction" | "spin" | "userPrize" | "smsLog" | "adminLog"
|
|
txIsolationLevel: Prisma.TransactionIsolationLevel
|
|
}
|
|
model: {
|
|
Admin: {
|
|
payload: Prisma.$AdminPayload<ExtArgs>
|
|
fields: Prisma.AdminFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.AdminFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.AdminFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.AdminFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.AdminFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.AdminFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.AdminCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.AdminCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.AdminCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.AdminDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.AdminUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.AdminDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.AdminUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.AdminUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.AdminAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateAdmin>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.AdminGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<AdminGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.AdminCountArgs<ExtArgs>
|
|
result: $Utils.Optional<AdminCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
User: {
|
|
payload: Prisma.$UserPayload<ExtArgs>
|
|
fields: Prisma.UserFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.UserFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.UserFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.UserFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.UserCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.UserCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.UserDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.UserUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.UserDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.UserUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.UserUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.UserAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateUser>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.UserGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<UserGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.UserCountArgs<ExtArgs>
|
|
result: $Utils.Optional<UserCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
OtpCode: {
|
|
payload: Prisma.$OtpCodePayload<ExtArgs>
|
|
fields: Prisma.OtpCodeFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.OtpCodeFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.OtpCodeFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.OtpCodeFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.OtpCodeFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.OtpCodeFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.OtpCodeCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.OtpCodeCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.OtpCodeCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.OtpCodeDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>
|
|
}
|
|
update: {
|
|
args: Prisma.OtpCodeUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.OtpCodeDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.OtpCodeUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.OtpCodeUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$OtpCodePayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.OtpCodeAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateOtpCode>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.OtpCodeGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<OtpCodeGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.OtpCodeCountArgs<ExtArgs>
|
|
result: $Utils.Optional<OtpCodeCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Campaign: {
|
|
payload: Prisma.$CampaignPayload<ExtArgs>
|
|
fields: Prisma.CampaignFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.CampaignFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.CampaignFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.CampaignFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.CampaignFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.CampaignFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.CampaignCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.CampaignCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.CampaignCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.CampaignDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.CampaignUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.CampaignDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.CampaignUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.CampaignUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$CampaignPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.CampaignAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateCampaign>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.CampaignGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<CampaignGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.CampaignCountArgs<ExtArgs>
|
|
result: $Utils.Optional<CampaignCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Prize: {
|
|
payload: Prisma.$PrizePayload<ExtArgs>
|
|
fields: Prisma.PrizeFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.PrizeFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.PrizeFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.PrizeFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.PrizeFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.PrizeFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.PrizeCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.PrizeCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.PrizeCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.PrizeDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>
|
|
}
|
|
update: {
|
|
args: Prisma.PrizeUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.PrizeDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.PrizeUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.PrizeUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PrizePayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.PrizeAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregatePrize>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.PrizeGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<PrizeGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.PrizeCountArgs<ExtArgs>
|
|
result: $Utils.Optional<PrizeCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
UserCampaign: {
|
|
payload: Prisma.$UserCampaignPayload<ExtArgs>
|
|
fields: Prisma.UserCampaignFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.UserCampaignFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.UserCampaignFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.UserCampaignFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.UserCampaignFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.UserCampaignFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.UserCampaignCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.UserCampaignCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.UserCampaignCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.UserCampaignDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.UserCampaignUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.UserCampaignDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.UserCampaignUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.UserCampaignUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserCampaignPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.UserCampaignAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateUserCampaign>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.UserCampaignGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<UserCampaignGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.UserCampaignCountArgs<ExtArgs>
|
|
result: $Utils.Optional<UserCampaignCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
ChanceTransaction: {
|
|
payload: Prisma.$ChanceTransactionPayload<ExtArgs>
|
|
fields: Prisma.ChanceTransactionFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.ChanceTransactionFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.ChanceTransactionFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.ChanceTransactionFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.ChanceTransactionFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.ChanceTransactionFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.ChanceTransactionCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.ChanceTransactionCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.ChanceTransactionCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.ChanceTransactionDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.ChanceTransactionUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.ChanceTransactionDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.ChanceTransactionUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.ChanceTransactionUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$ChanceTransactionPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.ChanceTransactionAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateChanceTransaction>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.ChanceTransactionGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<ChanceTransactionGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.ChanceTransactionCountArgs<ExtArgs>
|
|
result: $Utils.Optional<ChanceTransactionCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Spin: {
|
|
payload: Prisma.$SpinPayload<ExtArgs>
|
|
fields: Prisma.SpinFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.SpinFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.SpinFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.SpinFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.SpinFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.SpinFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.SpinCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.SpinCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.SpinCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.SpinDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.SpinUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.SpinDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.SpinUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.SpinUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SpinPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.SpinAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateSpin>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.SpinGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<SpinGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.SpinCountArgs<ExtArgs>
|
|
result: $Utils.Optional<SpinCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
UserPrize: {
|
|
payload: Prisma.$UserPrizePayload<ExtArgs>
|
|
fields: Prisma.UserPrizeFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.UserPrizeFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.UserPrizeFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.UserPrizeFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.UserPrizeFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.UserPrizeFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.UserPrizeCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.UserPrizeCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.UserPrizeCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.UserPrizeDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>
|
|
}
|
|
update: {
|
|
args: Prisma.UserPrizeUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.UserPrizeDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.UserPrizeUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.UserPrizeUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UserPrizePayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.UserPrizeAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateUserPrize>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.UserPrizeGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<UserPrizeGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.UserPrizeCountArgs<ExtArgs>
|
|
result: $Utils.Optional<UserPrizeCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
SmsLog: {
|
|
payload: Prisma.$SmsLogPayload<ExtArgs>
|
|
fields: Prisma.SmsLogFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.SmsLogFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.SmsLogFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.SmsLogFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.SmsLogFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.SmsLogFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.SmsLogCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.SmsLogCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.SmsLogCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.SmsLogDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.SmsLogUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.SmsLogDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.SmsLogUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.SmsLogUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$SmsLogPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.SmsLogAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateSmsLog>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.SmsLogGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<SmsLogGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.SmsLogCountArgs<ExtArgs>
|
|
result: $Utils.Optional<SmsLogCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
AdminLog: {
|
|
payload: Prisma.$AdminLogPayload<ExtArgs>
|
|
fields: Prisma.AdminLogFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.AdminLogFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.AdminLogFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.AdminLogFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.AdminLogFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.AdminLogFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.AdminLogCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.AdminLogCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.AdminLogCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.AdminLogDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.AdminLogUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.AdminLogDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.AdminLogUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
upsert: {
|
|
args: Prisma.AdminLogUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AdminLogPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.AdminLogAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateAdminLog>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.AdminLogGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<AdminLogGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.AdminLogCountArgs<ExtArgs>
|
|
result: $Utils.Optional<AdminLogCountAggregateOutputType> | 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
|
|
* ```
|
|
* // Defaults to stdout
|
|
* log: ['query', 'info', 'warn', 'error']
|
|
*
|
|
* // Emit as events
|
|
* log: [
|
|
* { emit: 'stdout', level: 'query' },
|
|
* { emit: 'stdout', level: 'info' },
|
|
* { emit: 'stdout', level: 'warn' }
|
|
* { emit: 'stdout', level: 'error' }
|
|
* ]
|
|
* ```
|
|
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
|
|
*/
|
|
log?: (LogLevel | LogDefinition)[]
|
|
/**
|
|
* The default values for transactionOptions
|
|
* maxWait ?= 2000
|
|
* timeout ?= 5000
|
|
*/
|
|
transactionOptions?: {
|
|
maxWait?: number
|
|
timeout?: number
|
|
isolationLevel?: Prisma.TransactionIsolationLevel
|
|
}
|
|
}
|
|
|
|
|
|
/* Types for Logging */
|
|
export type LogLevel = 'info' | 'query' | 'warn' | 'error'
|
|
export type LogDefinition = {
|
|
level: LogLevel
|
|
emit: 'stdout' | 'event'
|
|
}
|
|
|
|
export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
|
|
export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
|
|
GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
|
|
: never
|
|
|
|
export type QueryEvent = {
|
|
timestamp: Date
|
|
query: string
|
|
params: string
|
|
duration: number
|
|
target: string
|
|
}
|
|
|
|
export type LogEvent = {
|
|
timestamp: Date
|
|
message: string
|
|
target: string
|
|
}
|
|
/* End Types for Logging */
|
|
|
|
|
|
export type PrismaAction =
|
|
| 'findUnique'
|
|
| 'findUniqueOrThrow'
|
|
| 'findMany'
|
|
| 'findFirst'
|
|
| 'findFirstOrThrow'
|
|
| 'create'
|
|
| 'createMany'
|
|
| 'createManyAndReturn'
|
|
| 'update'
|
|
| 'updateMany'
|
|
| 'upsert'
|
|
| 'delete'
|
|
| 'deleteMany'
|
|
| 'executeRaw'
|
|
| 'queryRaw'
|
|
| 'aggregate'
|
|
| 'count'
|
|
| 'runCommandRaw'
|
|
| 'findRaw'
|
|
| 'groupBy'
|
|
|
|
/**
|
|
* These options are being passed into the middleware as "params"
|
|
*/
|
|
export type MiddlewareParams = {
|
|
model?: ModelName
|
|
action: PrismaAction
|
|
args: any
|
|
dataPath: string[]
|
|
runInTransaction: boolean
|
|
}
|
|
|
|
/**
|
|
* The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation
|
|
*/
|
|
export type Middleware<T = any> = (
|
|
params: MiddlewareParams,
|
|
next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
|
|
) => $Utils.JsPromise<T>
|
|
|
|
// tested in getLogLevel.test.ts
|
|
export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
|
|
|
|
/**
|
|
* `PrismaClient` proxy available in interactive transactions.
|
|
*/
|
|
export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>
|
|
|
|
export type Datasource = {
|
|
url?: string
|
|
}
|
|
|
|
/**
|
|
* Count Types
|
|
*/
|
|
|
|
|
|
/**
|
|
* Count Type AdminCountOutputType
|
|
*/
|
|
|
|
export type AdminCountOutputType = {
|
|
auditLogs: number
|
|
chanceTxns: number
|
|
}
|
|
|
|
export type AdminCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
auditLogs?: boolean | AdminCountOutputTypeCountAuditLogsArgs
|
|
chanceTxns?: boolean | AdminCountOutputTypeCountChanceTxnsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* AdminCountOutputType without action
|
|
*/
|
|
export type AdminCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminCountOutputType
|
|
*/
|
|
select?: AdminCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* AdminCountOutputType without action
|
|
*/
|
|
export type AdminCountOutputTypeCountAuditLogsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AdminLogWhereInput
|
|
}
|
|
|
|
/**
|
|
* AdminCountOutputType without action
|
|
*/
|
|
export type AdminCountOutputTypeCountChanceTxnsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ChanceTransactionWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type UserCountOutputType
|
|
*/
|
|
|
|
export type UserCountOutputType = {
|
|
userCampaigns: number
|
|
chanceTransactions: number
|
|
spins: number
|
|
userPrizes: number
|
|
otpCodes: number
|
|
smsLogs: number
|
|
}
|
|
|
|
export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
userCampaigns?: boolean | UserCountOutputTypeCountUserCampaignsArgs
|
|
chanceTransactions?: boolean | UserCountOutputTypeCountChanceTransactionsArgs
|
|
spins?: boolean | UserCountOutputTypeCountSpinsArgs
|
|
userPrizes?: boolean | UserCountOutputTypeCountUserPrizesArgs
|
|
otpCodes?: boolean | UserCountOutputTypeCountOtpCodesArgs
|
|
smsLogs?: boolean | UserCountOutputTypeCountSmsLogsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCountOutputType
|
|
*/
|
|
select?: UserCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountUserCampaignsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserCampaignWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountChanceTransactionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ChanceTransactionWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountSpinsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SpinWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountUserPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountOtpCodesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: OtpCodeWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCountOutputType without action
|
|
*/
|
|
export type UserCountOutputTypeCountSmsLogsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SmsLogWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type CampaignCountOutputType
|
|
*/
|
|
|
|
export type CampaignCountOutputType = {
|
|
prizes: number
|
|
userCampaigns: number
|
|
chanceTxns: number
|
|
spins: number
|
|
userPrizes: number
|
|
}
|
|
|
|
export type CampaignCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
prizes?: boolean | CampaignCountOutputTypeCountPrizesArgs
|
|
userCampaigns?: boolean | CampaignCountOutputTypeCountUserCampaignsArgs
|
|
chanceTxns?: boolean | CampaignCountOutputTypeCountChanceTxnsArgs
|
|
spins?: boolean | CampaignCountOutputTypeCountSpinsArgs
|
|
userPrizes?: boolean | CampaignCountOutputTypeCountUserPrizesArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* CampaignCountOutputType without action
|
|
*/
|
|
export type CampaignCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the CampaignCountOutputType
|
|
*/
|
|
select?: CampaignCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* CampaignCountOutputType without action
|
|
*/
|
|
export type CampaignCountOutputTypeCountPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: PrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* CampaignCountOutputType without action
|
|
*/
|
|
export type CampaignCountOutputTypeCountUserCampaignsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserCampaignWhereInput
|
|
}
|
|
|
|
/**
|
|
* CampaignCountOutputType without action
|
|
*/
|
|
export type CampaignCountOutputTypeCountChanceTxnsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ChanceTransactionWhereInput
|
|
}
|
|
|
|
/**
|
|
* CampaignCountOutputType without action
|
|
*/
|
|
export type CampaignCountOutputTypeCountSpinsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SpinWhereInput
|
|
}
|
|
|
|
/**
|
|
* CampaignCountOutputType without action
|
|
*/
|
|
export type CampaignCountOutputTypeCountUserPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type PrizeCountOutputType
|
|
*/
|
|
|
|
export type PrizeCountOutputType = {
|
|
spins: number
|
|
userPrizes: number
|
|
}
|
|
|
|
export type PrizeCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
spins?: boolean | PrizeCountOutputTypeCountSpinsArgs
|
|
userPrizes?: boolean | PrizeCountOutputTypeCountUserPrizesArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* PrizeCountOutputType without action
|
|
*/
|
|
export type PrizeCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the PrizeCountOutputType
|
|
*/
|
|
select?: PrizeCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* PrizeCountOutputType without action
|
|
*/
|
|
export type PrizeCountOutputTypeCountSpinsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SpinWhereInput
|
|
}
|
|
|
|
/**
|
|
* PrizeCountOutputType without action
|
|
*/
|
|
export type PrizeCountOutputTypeCountUserPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Models
|
|
*/
|
|
|
|
/**
|
|
* Model Admin
|
|
*/
|
|
|
|
export type AggregateAdmin = {
|
|
_count: AdminCountAggregateOutputType | null
|
|
_min: AdminMinAggregateOutputType | null
|
|
_max: AdminMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type AdminMinAggregateOutputType = {
|
|
id: string | null
|
|
name: string | null
|
|
mobile: string | null
|
|
email: string | null
|
|
passwordHash: string | null
|
|
role: $Enums.AdminRole | null
|
|
status: $Enums.AdminStatus | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type AdminMaxAggregateOutputType = {
|
|
id: string | null
|
|
name: string | null
|
|
mobile: string | null
|
|
email: string | null
|
|
passwordHash: string | null
|
|
role: $Enums.AdminRole | null
|
|
status: $Enums.AdminStatus | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type AdminCountAggregateOutputType = {
|
|
id: number
|
|
name: number
|
|
mobile: number
|
|
email: number
|
|
passwordHash: number
|
|
role: number
|
|
status: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type AdminMinAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
mobile?: true
|
|
email?: true
|
|
passwordHash?: true
|
|
role?: true
|
|
status?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type AdminMaxAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
mobile?: true
|
|
email?: true
|
|
passwordHash?: true
|
|
role?: true
|
|
status?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type AdminCountAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
mobile?: true
|
|
email?: true
|
|
passwordHash?: true
|
|
role?: true
|
|
status?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type AdminAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Admin to aggregate.
|
|
*/
|
|
where?: AdminWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Admins to fetch.
|
|
*/
|
|
orderBy?: AdminOrderByWithRelationInput | AdminOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: AdminWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Admins 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` Admins.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Admins
|
|
**/
|
|
_count?: true | AdminCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: AdminMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: AdminMaxAggregateInputType
|
|
}
|
|
|
|
export type GetAdminAggregateType<T extends AdminAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateAdmin]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateAdmin[P]>
|
|
: GetScalarType<T[P], AggregateAdmin[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type AdminGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AdminWhereInput
|
|
orderBy?: AdminOrderByWithAggregationInput | AdminOrderByWithAggregationInput[]
|
|
by: AdminScalarFieldEnum[] | AdminScalarFieldEnum
|
|
having?: AdminScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: AdminCountAggregateInputType | true
|
|
_min?: AdminMinAggregateInputType
|
|
_max?: AdminMaxAggregateInputType
|
|
}
|
|
|
|
export type AdminGroupByOutputType = {
|
|
id: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role: $Enums.AdminRole
|
|
status: $Enums.AdminStatus
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: AdminCountAggregateOutputType | null
|
|
_min: AdminMinAggregateOutputType | null
|
|
_max: AdminMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetAdminGroupByPayload<T extends AdminGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<AdminGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof AdminGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], AdminGroupByOutputType[P]>
|
|
: GetScalarType<T[P], AdminGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type AdminSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
mobile?: boolean
|
|
email?: boolean
|
|
passwordHash?: boolean
|
|
role?: boolean
|
|
status?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
auditLogs?: boolean | Admin$auditLogsArgs<ExtArgs>
|
|
chanceTxns?: boolean | Admin$chanceTxnsArgs<ExtArgs>
|
|
_count?: boolean | AdminCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["admin"]>
|
|
|
|
export type AdminSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
mobile?: boolean
|
|
email?: boolean
|
|
passwordHash?: boolean
|
|
role?: boolean
|
|
status?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["admin"]>
|
|
|
|
export type AdminSelectScalar = {
|
|
id?: boolean
|
|
name?: boolean
|
|
mobile?: boolean
|
|
email?: boolean
|
|
passwordHash?: boolean
|
|
role?: boolean
|
|
status?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type AdminInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
auditLogs?: boolean | Admin$auditLogsArgs<ExtArgs>
|
|
chanceTxns?: boolean | Admin$chanceTxnsArgs<ExtArgs>
|
|
_count?: boolean | AdminCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type AdminIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $AdminPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Admin"
|
|
objects: {
|
|
auditLogs: Prisma.$AdminLogPayload<ExtArgs>[]
|
|
chanceTxns: Prisma.$ChanceTransactionPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role: $Enums.AdminRole
|
|
status: $Enums.AdminStatus
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["admin"]>
|
|
composites: {}
|
|
}
|
|
|
|
type AdminGetPayload<S extends boolean | null | undefined | AdminDefaultArgs> = $Result.GetResult<Prisma.$AdminPayload, S>
|
|
|
|
type AdminCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<AdminFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: AdminCountAggregateInputType | true
|
|
}
|
|
|
|
export interface AdminDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Admin'], meta: { name: 'Admin' } }
|
|
/**
|
|
* Find zero or one Admin that matches the filter.
|
|
* @param {AdminFindUniqueArgs} args - Arguments to find a Admin
|
|
* @example
|
|
* // Get one Admin
|
|
* const admin = await prisma.admin.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends AdminFindUniqueArgs>(args: SelectSubset<T, AdminFindUniqueArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one Admin that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {AdminFindUniqueOrThrowArgs} args - Arguments to find a Admin
|
|
* @example
|
|
* // Get one Admin
|
|
* const admin = await prisma.admin.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends AdminFindUniqueOrThrowArgs>(args: SelectSubset<T, AdminFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Admin 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 {AdminFindFirstArgs} args - Arguments to find a Admin
|
|
* @example
|
|
* // Get one Admin
|
|
* const admin = await prisma.admin.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends AdminFindFirstArgs>(args?: SelectSubset<T, AdminFindFirstArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Admin 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 {AdminFindFirstOrThrowArgs} args - Arguments to find a Admin
|
|
* @example
|
|
* // Get one Admin
|
|
* const admin = await prisma.admin.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends AdminFindFirstOrThrowArgs>(args?: SelectSubset<T, AdminFindFirstOrThrowArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more Admins 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 {AdminFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Admins
|
|
* const admins = await prisma.admin.findMany()
|
|
*
|
|
* // Get first 10 Admins
|
|
* const admins = await prisma.admin.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const adminWithIdOnly = await prisma.admin.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends AdminFindManyArgs>(args?: SelectSubset<T, AdminFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a Admin.
|
|
* @param {AdminCreateArgs} args - Arguments to create a Admin.
|
|
* @example
|
|
* // Create one Admin
|
|
* const Admin = await prisma.admin.create({
|
|
* data: {
|
|
* // ... data to create a Admin
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends AdminCreateArgs>(args: SelectSubset<T, AdminCreateArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many Admins.
|
|
* @param {AdminCreateManyArgs} args - Arguments to create many Admins.
|
|
* @example
|
|
* // Create many Admins
|
|
* const admin = await prisma.admin.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends AdminCreateManyArgs>(args?: SelectSubset<T, AdminCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Admins and returns the data saved in the database.
|
|
* @param {AdminCreateManyAndReturnArgs} args - Arguments to create many Admins.
|
|
* @example
|
|
* // Create many Admins
|
|
* const admin = await prisma.admin.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Admins and only return the `id`
|
|
* const adminWithIdOnly = await prisma.admin.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 AdminCreateManyAndReturnArgs>(args?: SelectSubset<T, AdminCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a Admin.
|
|
* @param {AdminDeleteArgs} args - Arguments to delete one Admin.
|
|
* @example
|
|
* // Delete one Admin
|
|
* const Admin = await prisma.admin.delete({
|
|
* where: {
|
|
* // ... filter to delete one Admin
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends AdminDeleteArgs>(args: SelectSubset<T, AdminDeleteArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one Admin.
|
|
* @param {AdminUpdateArgs} args - Arguments to update one Admin.
|
|
* @example
|
|
* // Update one Admin
|
|
* const admin = await prisma.admin.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends AdminUpdateArgs>(args: SelectSubset<T, AdminUpdateArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more Admins.
|
|
* @param {AdminDeleteManyArgs} args - Arguments to filter Admins to delete.
|
|
* @example
|
|
* // Delete a few Admins
|
|
* const { count } = await prisma.admin.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends AdminDeleteManyArgs>(args?: SelectSubset<T, AdminDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Admins.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Admins
|
|
* const admin = await prisma.admin.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends AdminUpdateManyArgs>(args: SelectSubset<T, AdminUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one Admin.
|
|
* @param {AdminUpsertArgs} args - Arguments to update or create a Admin.
|
|
* @example
|
|
* // Update or create a Admin
|
|
* const admin = await prisma.admin.upsert({
|
|
* create: {
|
|
* // ... data to create a Admin
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Admin we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends AdminUpsertArgs>(args: SelectSubset<T, AdminUpsertArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of Admins.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminCountArgs} args - Arguments to filter Admins to count.
|
|
* @example
|
|
* // Count the number of Admins
|
|
* const count = await prisma.admin.count({
|
|
* where: {
|
|
* // ... the filter for the Admins we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends AdminCountArgs>(
|
|
args?: Subset<T, AdminCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], AdminCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Admin.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminAggregateArgs} 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 AdminAggregateArgs>(args: Subset<T, AdminAggregateArgs>): Prisma.PrismaPromise<GetAdminAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Admin.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminGroupByArgs} 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 AdminGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: AdminGroupByArgs['orderBy'] }
|
|
: { orderBy?: AdminGroupByArgs['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, AdminGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdminGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Admin model
|
|
*/
|
|
readonly fields: AdminFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Admin.
|
|
* 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__AdminClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
auditLogs<T extends Admin$auditLogsArgs<ExtArgs> = {}>(args?: Subset<T, Admin$auditLogsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "findMany"> | Null>
|
|
chanceTxns<T extends Admin$chanceTxnsArgs<ExtArgs> = {}>(args?: Subset<T, Admin$chanceTxnsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findMany"> | 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 Admin model
|
|
*/
|
|
interface AdminFieldRefs {
|
|
readonly id: FieldRef<"Admin", 'String'>
|
|
readonly name: FieldRef<"Admin", 'String'>
|
|
readonly mobile: FieldRef<"Admin", 'String'>
|
|
readonly email: FieldRef<"Admin", 'String'>
|
|
readonly passwordHash: FieldRef<"Admin", 'String'>
|
|
readonly role: FieldRef<"Admin", 'AdminRole'>
|
|
readonly status: FieldRef<"Admin", 'AdminStatus'>
|
|
readonly createdAt: FieldRef<"Admin", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Admin", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Admin findUnique
|
|
*/
|
|
export type AdminFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Admin to fetch.
|
|
*/
|
|
where: AdminWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Admin findUniqueOrThrow
|
|
*/
|
|
export type AdminFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Admin to fetch.
|
|
*/
|
|
where: AdminWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Admin findFirst
|
|
*/
|
|
export type AdminFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Admin to fetch.
|
|
*/
|
|
where?: AdminWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Admins to fetch.
|
|
*/
|
|
orderBy?: AdminOrderByWithRelationInput | AdminOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Admins.
|
|
*/
|
|
cursor?: AdminWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Admins 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` Admins.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Admins.
|
|
*/
|
|
distinct?: AdminScalarFieldEnum | AdminScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Admin findFirstOrThrow
|
|
*/
|
|
export type AdminFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Admin to fetch.
|
|
*/
|
|
where?: AdminWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Admins to fetch.
|
|
*/
|
|
orderBy?: AdminOrderByWithRelationInput | AdminOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Admins.
|
|
*/
|
|
cursor?: AdminWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Admins 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` Admins.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Admins.
|
|
*/
|
|
distinct?: AdminScalarFieldEnum | AdminScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Admin findMany
|
|
*/
|
|
export type AdminFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Admins to fetch.
|
|
*/
|
|
where?: AdminWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Admins to fetch.
|
|
*/
|
|
orderBy?: AdminOrderByWithRelationInput | AdminOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Admins.
|
|
*/
|
|
cursor?: AdminWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Admins 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` Admins.
|
|
*/
|
|
skip?: number
|
|
distinct?: AdminScalarFieldEnum | AdminScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Admin create
|
|
*/
|
|
export type AdminCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Admin.
|
|
*/
|
|
data: XOR<AdminCreateInput, AdminUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Admin createMany
|
|
*/
|
|
export type AdminCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Admins.
|
|
*/
|
|
data: AdminCreateManyInput | AdminCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Admin createManyAndReturn
|
|
*/
|
|
export type AdminCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Admins.
|
|
*/
|
|
data: AdminCreateManyInput | AdminCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Admin update
|
|
*/
|
|
export type AdminUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Admin.
|
|
*/
|
|
data: XOR<AdminUpdateInput, AdminUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Admin to update.
|
|
*/
|
|
where: AdminWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Admin updateMany
|
|
*/
|
|
export type AdminUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Admins.
|
|
*/
|
|
data: XOR<AdminUpdateManyMutationInput, AdminUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Admins to update
|
|
*/
|
|
where?: AdminWhereInput
|
|
}
|
|
|
|
/**
|
|
* Admin upsert
|
|
*/
|
|
export type AdminUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Admin to update in case it exists.
|
|
*/
|
|
where: AdminWhereUniqueInput
|
|
/**
|
|
* In case the Admin found by the `where` argument doesn't exist, create a new Admin with this data.
|
|
*/
|
|
create: XOR<AdminCreateInput, AdminUncheckedCreateInput>
|
|
/**
|
|
* In case the Admin was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<AdminUpdateInput, AdminUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Admin delete
|
|
*/
|
|
export type AdminDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Admin to delete.
|
|
*/
|
|
where: AdminWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Admin deleteMany
|
|
*/
|
|
export type AdminDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Admins to delete
|
|
*/
|
|
where?: AdminWhereInput
|
|
}
|
|
|
|
/**
|
|
* Admin.auditLogs
|
|
*/
|
|
export type Admin$auditLogsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
where?: AdminLogWhereInput
|
|
orderBy?: AdminLogOrderByWithRelationInput | AdminLogOrderByWithRelationInput[]
|
|
cursor?: AdminLogWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: AdminLogScalarFieldEnum | AdminLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Admin.chanceTxns
|
|
*/
|
|
export type Admin$chanceTxnsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
where?: ChanceTransactionWhereInput
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: ChanceTransactionScalarFieldEnum | ChanceTransactionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Admin without action
|
|
*/
|
|
export type AdminDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model User
|
|
*/
|
|
|
|
export type AggregateUser = {
|
|
_count: UserCountAggregateOutputType | null
|
|
_min: UserMinAggregateOutputType | null
|
|
_max: UserMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type UserMinAggregateOutputType = {
|
|
id: string | null
|
|
mobile: string | null
|
|
name: string | null
|
|
status: $Enums.UserStatus | null
|
|
lastLoginAt: Date | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type UserMaxAggregateOutputType = {
|
|
id: string | null
|
|
mobile: string | null
|
|
name: string | null
|
|
status: $Enums.UserStatus | null
|
|
lastLoginAt: Date | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type UserCountAggregateOutputType = {
|
|
id: number
|
|
mobile: number
|
|
name: number
|
|
status: number
|
|
lastLoginAt: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type UserMinAggregateInputType = {
|
|
id?: true
|
|
mobile?: true
|
|
name?: true
|
|
status?: true
|
|
lastLoginAt?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type UserMaxAggregateInputType = {
|
|
id?: true
|
|
mobile?: true
|
|
name?: true
|
|
status?: true
|
|
lastLoginAt?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type UserCountAggregateInputType = {
|
|
id?: true
|
|
mobile?: true
|
|
name?: true
|
|
status?: true
|
|
lastLoginAt?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which User to aggregate.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Users
|
|
**/
|
|
_count?: true | UserCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: UserMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: UserMaxAggregateInputType
|
|
}
|
|
|
|
export type GetUserAggregateType<T extends UserAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateUser]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateUser[P]>
|
|
: GetScalarType<T[P], AggregateUser[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserWhereInput
|
|
orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
|
|
by: UserScalarFieldEnum[] | UserScalarFieldEnum
|
|
having?: UserScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: UserCountAggregateInputType | true
|
|
_min?: UserMinAggregateInputType
|
|
_max?: UserMaxAggregateInputType
|
|
}
|
|
|
|
export type UserGroupByOutputType = {
|
|
id: string
|
|
mobile: string
|
|
name: string | null
|
|
status: $Enums.UserStatus
|
|
lastLoginAt: Date | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: UserCountAggregateOutputType | null
|
|
_min: UserMinAggregateOutputType | null
|
|
_max: UserMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<UserGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], UserGroupByOutputType[P]>
|
|
: GetScalarType<T[P], UserGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
mobile?: boolean
|
|
name?: boolean
|
|
status?: boolean
|
|
lastLoginAt?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
userCampaigns?: boolean | User$userCampaignsArgs<ExtArgs>
|
|
chanceTransactions?: boolean | User$chanceTransactionsArgs<ExtArgs>
|
|
spins?: boolean | User$spinsArgs<ExtArgs>
|
|
userPrizes?: boolean | User$userPrizesArgs<ExtArgs>
|
|
otpCodes?: boolean | User$otpCodesArgs<ExtArgs>
|
|
smsLogs?: boolean | User$smsLogsArgs<ExtArgs>
|
|
_count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["user"]>
|
|
|
|
export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
mobile?: boolean
|
|
name?: boolean
|
|
status?: boolean
|
|
lastLoginAt?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["user"]>
|
|
|
|
export type UserSelectScalar = {
|
|
id?: boolean
|
|
mobile?: boolean
|
|
name?: boolean
|
|
status?: boolean
|
|
lastLoginAt?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
userCampaigns?: boolean | User$userCampaignsArgs<ExtArgs>
|
|
chanceTransactions?: boolean | User$chanceTransactionsArgs<ExtArgs>
|
|
spins?: boolean | User$spinsArgs<ExtArgs>
|
|
userPrizes?: boolean | User$userPrizesArgs<ExtArgs>
|
|
otpCodes?: boolean | User$otpCodesArgs<ExtArgs>
|
|
smsLogs?: boolean | User$smsLogsArgs<ExtArgs>
|
|
_count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "User"
|
|
objects: {
|
|
userCampaigns: Prisma.$UserCampaignPayload<ExtArgs>[]
|
|
chanceTransactions: Prisma.$ChanceTransactionPayload<ExtArgs>[]
|
|
spins: Prisma.$SpinPayload<ExtArgs>[]
|
|
userPrizes: Prisma.$UserPrizePayload<ExtArgs>[]
|
|
otpCodes: Prisma.$OtpCodePayload<ExtArgs>[]
|
|
smsLogs: Prisma.$SmsLogPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
mobile: string
|
|
name: string | null
|
|
status: $Enums.UserStatus
|
|
lastLoginAt: Date | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["user"]>
|
|
composites: {}
|
|
}
|
|
|
|
type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>
|
|
|
|
type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<UserFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: UserCountAggregateInputType | true
|
|
}
|
|
|
|
export interface UserDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } }
|
|
/**
|
|
* Find zero or one User that matches the filter.
|
|
* @param {UserFindUniqueArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends UserFindUniqueArgs>(args: SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one User that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first User that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserFindFirstArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends UserFindFirstArgs>(args?: SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first User that matches the filter or
|
|
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
|
|
* @example
|
|
* // Get one User
|
|
* const user = await prisma.user.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more Users that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Users
|
|
* const users = await prisma.user.findMany()
|
|
*
|
|
* // Get first 10 Users
|
|
* const users = await prisma.user.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const userWithIdOnly = await prisma.user.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends UserFindManyArgs>(args?: SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a User.
|
|
* @param {UserCreateArgs} args - Arguments to create a User.
|
|
* @example
|
|
* // Create one User
|
|
* const User = await prisma.user.create({
|
|
* data: {
|
|
* // ... data to create a User
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many Users.
|
|
* @param {UserCreateManyArgs} args - Arguments to create many Users.
|
|
* @example
|
|
* // Create many Users
|
|
* const user = await prisma.user.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends UserCreateManyArgs>(args?: SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Users and returns the data saved in the database.
|
|
* @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
|
|
* @example
|
|
* // Create many Users
|
|
* const user = await prisma.user.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Users and only return the `id`
|
|
* const userWithIdOnly = await prisma.user.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 UserCreateManyAndReturnArgs>(args?: SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a User.
|
|
* @param {UserDeleteArgs} args - Arguments to delete one User.
|
|
* @example
|
|
* // Delete one User
|
|
* const User = await prisma.user.delete({
|
|
* where: {
|
|
* // ... filter to delete one User
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one User.
|
|
* @param {UserUpdateArgs} args - Arguments to update one User.
|
|
* @example
|
|
* // Update one User
|
|
* const user = await prisma.user.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends UserUpdateArgs>(args: SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more Users.
|
|
* @param {UserDeleteManyArgs} args - Arguments to filter Users to delete.
|
|
* @example
|
|
* // Delete a few Users
|
|
* const { count } = await prisma.user.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends UserDeleteManyArgs>(args?: SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Users.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Users
|
|
* const user = await prisma.user.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends UserUpdateManyArgs>(args: SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one User.
|
|
* @param {UserUpsertArgs} args - Arguments to update or create a User.
|
|
* @example
|
|
* // Update or create a User
|
|
* const user = await prisma.user.upsert({
|
|
* create: {
|
|
* // ... data to create a User
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the User we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends UserUpsertArgs>(args: SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of Users.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserCountArgs} args - Arguments to filter Users to count.
|
|
* @example
|
|
* // Count the number of Users
|
|
* const count = await prisma.user.count({
|
|
* where: {
|
|
* // ... the filter for the Users we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends UserCountArgs>(
|
|
args?: Subset<T, UserCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], UserCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a User.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>
|
|
|
|
/**
|
|
* Group by User.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserGroupByArgs} args - Group by arguments.
|
|
* @example
|
|
* // Group by city, order by createdAt, get count
|
|
* const result = await prisma.user.groupBy({
|
|
* by: ['city', 'createdAt'],
|
|
* orderBy: {
|
|
* createdAt: true
|
|
* },
|
|
* _count: {
|
|
* _all: true
|
|
* },
|
|
* })
|
|
*
|
|
**/
|
|
groupBy<
|
|
T extends UserGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: UserGroupByArgs['orderBy'] }
|
|
: { orderBy?: UserGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the User model
|
|
*/
|
|
readonly fields: UserFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for User.
|
|
* Why is this prefixed with `Prisma__`?
|
|
* Because we want to prevent naming conflicts as mentioned in
|
|
* https://github.com/prisma/prisma-client-js/issues/707
|
|
*/
|
|
export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
userCampaigns<T extends User$userCampaignsArgs<ExtArgs> = {}>(args?: Subset<T, User$userCampaignsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findMany"> | Null>
|
|
chanceTransactions<T extends User$chanceTransactionsArgs<ExtArgs> = {}>(args?: Subset<T, User$chanceTransactionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findMany"> | Null>
|
|
spins<T extends User$spinsArgs<ExtArgs> = {}>(args?: Subset<T, User$spinsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findMany"> | Null>
|
|
userPrizes<T extends User$userPrizesArgs<ExtArgs> = {}>(args?: Subset<T, User$userPrizesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findMany"> | Null>
|
|
otpCodes<T extends User$otpCodesArgs<ExtArgs> = {}>(args?: Subset<T, User$otpCodesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "findMany"> | Null>
|
|
smsLogs<T extends User$smsLogsArgs<ExtArgs> = {}>(args?: Subset<T, User$smsLogsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "findMany"> | Null>
|
|
/**
|
|
* Attaches callbacks for the resolution and/or rejection of the Promise.
|
|
* @param onfulfilled The callback to execute when the Promise is resolved.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of which ever callback is executed.
|
|
*/
|
|
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
|
|
/**
|
|
* Attaches a callback for only the rejection of the Promise.
|
|
* @param onrejected The callback to execute when the Promise is rejected.
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
|
|
/**
|
|
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
|
* resolved value cannot be modified from the callback.
|
|
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
|
* @returns A Promise for the completion of the callback.
|
|
*/
|
|
finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fields of the User model
|
|
*/
|
|
interface UserFieldRefs {
|
|
readonly id: FieldRef<"User", 'String'>
|
|
readonly mobile: FieldRef<"User", 'String'>
|
|
readonly name: FieldRef<"User", 'String'>
|
|
readonly status: FieldRef<"User", 'UserStatus'>
|
|
readonly lastLoginAt: FieldRef<"User", 'DateTime'>
|
|
readonly createdAt: FieldRef<"User", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"User", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* User findUnique
|
|
*/
|
|
export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User findUniqueOrThrow
|
|
*/
|
|
export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User findFirst
|
|
*/
|
|
export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Users.
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Users.
|
|
*/
|
|
distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User findFirstOrThrow
|
|
*/
|
|
export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which User to fetch.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Users.
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Users.
|
|
*/
|
|
distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User findMany
|
|
*/
|
|
export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Users to fetch.
|
|
*/
|
|
where?: UserWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Users to fetch.
|
|
*/
|
|
orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Users.
|
|
*/
|
|
cursor?: UserWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Users from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Users.
|
|
*/
|
|
skip?: number
|
|
distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User create
|
|
*/
|
|
export type UserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a User.
|
|
*/
|
|
data: XOR<UserCreateInput, UserUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* User createMany
|
|
*/
|
|
export type UserCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Users.
|
|
*/
|
|
data: UserCreateManyInput | UserCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* User createManyAndReturn
|
|
*/
|
|
export type UserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Users.
|
|
*/
|
|
data: UserCreateManyInput | UserCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* User update
|
|
*/
|
|
export type UserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a User.
|
|
*/
|
|
data: XOR<UserUpdateInput, UserUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which User to update.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User updateMany
|
|
*/
|
|
export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Users.
|
|
*/
|
|
data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Users to update
|
|
*/
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
/**
|
|
* User upsert
|
|
*/
|
|
export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the User to update in case it exists.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
/**
|
|
* In case the User found by the `where` argument doesn't exist, create a new User with this data.
|
|
*/
|
|
create: XOR<UserCreateInput, UserUncheckedCreateInput>
|
|
/**
|
|
* In case the User was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* User delete
|
|
*/
|
|
export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which User to delete.
|
|
*/
|
|
where: UserWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* User deleteMany
|
|
*/
|
|
export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Users to delete
|
|
*/
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
/**
|
|
* User.userCampaigns
|
|
*/
|
|
export type User$userCampaignsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
where?: UserCampaignWhereInput
|
|
orderBy?: UserCampaignOrderByWithRelationInput | UserCampaignOrderByWithRelationInput[]
|
|
cursor?: UserCampaignWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: UserCampaignScalarFieldEnum | UserCampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.chanceTransactions
|
|
*/
|
|
export type User$chanceTransactionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
where?: ChanceTransactionWhereInput
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: ChanceTransactionScalarFieldEnum | ChanceTransactionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.spins
|
|
*/
|
|
export type User$spinsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
where?: SpinWhereInput
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
cursor?: SpinWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SpinScalarFieldEnum | SpinScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.userPrizes
|
|
*/
|
|
export type User$userPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
where?: UserPrizeWhereInput
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: UserPrizeScalarFieldEnum | UserPrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.otpCodes
|
|
*/
|
|
export type User$otpCodesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
where?: OtpCodeWhereInput
|
|
orderBy?: OtpCodeOrderByWithRelationInput | OtpCodeOrderByWithRelationInput[]
|
|
cursor?: OtpCodeWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: OtpCodeScalarFieldEnum | OtpCodeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User.smsLogs
|
|
*/
|
|
export type User$smsLogsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
where?: SmsLogWhereInput
|
|
orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
|
|
cursor?: SmsLogWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* User without action
|
|
*/
|
|
export type UserDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model OtpCode
|
|
*/
|
|
|
|
export type AggregateOtpCode = {
|
|
_count: OtpCodeCountAggregateOutputType | null
|
|
_avg: OtpCodeAvgAggregateOutputType | null
|
|
_sum: OtpCodeSumAggregateOutputType | null
|
|
_min: OtpCodeMinAggregateOutputType | null
|
|
_max: OtpCodeMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type OtpCodeAvgAggregateOutputType = {
|
|
attempts: number | null
|
|
}
|
|
|
|
export type OtpCodeSumAggregateOutputType = {
|
|
attempts: number | null
|
|
}
|
|
|
|
export type OtpCodeMinAggregateOutputType = {
|
|
id: string | null
|
|
mobile: string | null
|
|
code: string | null
|
|
userId: string | null
|
|
attempts: number | null
|
|
consumed: boolean | null
|
|
expiresAt: Date | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type OtpCodeMaxAggregateOutputType = {
|
|
id: string | null
|
|
mobile: string | null
|
|
code: string | null
|
|
userId: string | null
|
|
attempts: number | null
|
|
consumed: boolean | null
|
|
expiresAt: Date | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type OtpCodeCountAggregateOutputType = {
|
|
id: number
|
|
mobile: number
|
|
code: number
|
|
userId: number
|
|
attempts: number
|
|
consumed: number
|
|
expiresAt: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type OtpCodeAvgAggregateInputType = {
|
|
attempts?: true
|
|
}
|
|
|
|
export type OtpCodeSumAggregateInputType = {
|
|
attempts?: true
|
|
}
|
|
|
|
export type OtpCodeMinAggregateInputType = {
|
|
id?: true
|
|
mobile?: true
|
|
code?: true
|
|
userId?: true
|
|
attempts?: true
|
|
consumed?: true
|
|
expiresAt?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type OtpCodeMaxAggregateInputType = {
|
|
id?: true
|
|
mobile?: true
|
|
code?: true
|
|
userId?: true
|
|
attempts?: true
|
|
consumed?: true
|
|
expiresAt?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type OtpCodeCountAggregateInputType = {
|
|
id?: true
|
|
mobile?: true
|
|
code?: true
|
|
userId?: true
|
|
attempts?: true
|
|
consumed?: true
|
|
expiresAt?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type OtpCodeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which OtpCode to aggregate.
|
|
*/
|
|
where?: OtpCodeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of OtpCodes to fetch.
|
|
*/
|
|
orderBy?: OtpCodeOrderByWithRelationInput | OtpCodeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: OtpCodeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` OtpCodes 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` OtpCodes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned OtpCodes
|
|
**/
|
|
_count?: true | OtpCodeCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: OtpCodeAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: OtpCodeSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: OtpCodeMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: OtpCodeMaxAggregateInputType
|
|
}
|
|
|
|
export type GetOtpCodeAggregateType<T extends OtpCodeAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateOtpCode]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateOtpCode[P]>
|
|
: GetScalarType<T[P], AggregateOtpCode[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type OtpCodeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: OtpCodeWhereInput
|
|
orderBy?: OtpCodeOrderByWithAggregationInput | OtpCodeOrderByWithAggregationInput[]
|
|
by: OtpCodeScalarFieldEnum[] | OtpCodeScalarFieldEnum
|
|
having?: OtpCodeScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: OtpCodeCountAggregateInputType | true
|
|
_avg?: OtpCodeAvgAggregateInputType
|
|
_sum?: OtpCodeSumAggregateInputType
|
|
_min?: OtpCodeMinAggregateInputType
|
|
_max?: OtpCodeMaxAggregateInputType
|
|
}
|
|
|
|
export type OtpCodeGroupByOutputType = {
|
|
id: string
|
|
mobile: string
|
|
code: string
|
|
userId: string | null
|
|
attempts: number
|
|
consumed: boolean
|
|
expiresAt: Date
|
|
createdAt: Date
|
|
_count: OtpCodeCountAggregateOutputType | null
|
|
_avg: OtpCodeAvgAggregateOutputType | null
|
|
_sum: OtpCodeSumAggregateOutputType | null
|
|
_min: OtpCodeMinAggregateOutputType | null
|
|
_max: OtpCodeMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetOtpCodeGroupByPayload<T extends OtpCodeGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<OtpCodeGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof OtpCodeGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], OtpCodeGroupByOutputType[P]>
|
|
: GetScalarType<T[P], OtpCodeGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type OtpCodeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
mobile?: boolean
|
|
code?: boolean
|
|
userId?: boolean
|
|
attempts?: boolean
|
|
consumed?: boolean
|
|
expiresAt?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | OtpCode$userArgs<ExtArgs>
|
|
}, ExtArgs["result"]["otpCode"]>
|
|
|
|
export type OtpCodeSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
mobile?: boolean
|
|
code?: boolean
|
|
userId?: boolean
|
|
attempts?: boolean
|
|
consumed?: boolean
|
|
expiresAt?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | OtpCode$userArgs<ExtArgs>
|
|
}, ExtArgs["result"]["otpCode"]>
|
|
|
|
export type OtpCodeSelectScalar = {
|
|
id?: boolean
|
|
mobile?: boolean
|
|
code?: boolean
|
|
userId?: boolean
|
|
attempts?: boolean
|
|
consumed?: boolean
|
|
expiresAt?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type OtpCodeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | OtpCode$userArgs<ExtArgs>
|
|
}
|
|
export type OtpCodeIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | OtpCode$userArgs<ExtArgs>
|
|
}
|
|
|
|
export type $OtpCodePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "OtpCode"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs> | null
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
mobile: string
|
|
code: string
|
|
userId: string | null
|
|
attempts: number
|
|
consumed: boolean
|
|
expiresAt: Date
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["otpCode"]>
|
|
composites: {}
|
|
}
|
|
|
|
type OtpCodeGetPayload<S extends boolean | null | undefined | OtpCodeDefaultArgs> = $Result.GetResult<Prisma.$OtpCodePayload, S>
|
|
|
|
type OtpCodeCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<OtpCodeFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: OtpCodeCountAggregateInputType | true
|
|
}
|
|
|
|
export interface OtpCodeDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['OtpCode'], meta: { name: 'OtpCode' } }
|
|
/**
|
|
* Find zero or one OtpCode that matches the filter.
|
|
* @param {OtpCodeFindUniqueArgs} args - Arguments to find a OtpCode
|
|
* @example
|
|
* // Get one OtpCode
|
|
* const otpCode = await prisma.otpCode.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends OtpCodeFindUniqueArgs>(args: SelectSubset<T, OtpCodeFindUniqueArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one OtpCode that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {OtpCodeFindUniqueOrThrowArgs} args - Arguments to find a OtpCode
|
|
* @example
|
|
* // Get one OtpCode
|
|
* const otpCode = await prisma.otpCode.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends OtpCodeFindUniqueOrThrowArgs>(args: SelectSubset<T, OtpCodeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first OtpCode 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 {OtpCodeFindFirstArgs} args - Arguments to find a OtpCode
|
|
* @example
|
|
* // Get one OtpCode
|
|
* const otpCode = await prisma.otpCode.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends OtpCodeFindFirstArgs>(args?: SelectSubset<T, OtpCodeFindFirstArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first OtpCode 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 {OtpCodeFindFirstOrThrowArgs} args - Arguments to find a OtpCode
|
|
* @example
|
|
* // Get one OtpCode
|
|
* const otpCode = await prisma.otpCode.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends OtpCodeFindFirstOrThrowArgs>(args?: SelectSubset<T, OtpCodeFindFirstOrThrowArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more OtpCodes 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 {OtpCodeFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all OtpCodes
|
|
* const otpCodes = await prisma.otpCode.findMany()
|
|
*
|
|
* // Get first 10 OtpCodes
|
|
* const otpCodes = await prisma.otpCode.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const otpCodeWithIdOnly = await prisma.otpCode.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends OtpCodeFindManyArgs>(args?: SelectSubset<T, OtpCodeFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a OtpCode.
|
|
* @param {OtpCodeCreateArgs} args - Arguments to create a OtpCode.
|
|
* @example
|
|
* // Create one OtpCode
|
|
* const OtpCode = await prisma.otpCode.create({
|
|
* data: {
|
|
* // ... data to create a OtpCode
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends OtpCodeCreateArgs>(args: SelectSubset<T, OtpCodeCreateArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many OtpCodes.
|
|
* @param {OtpCodeCreateManyArgs} args - Arguments to create many OtpCodes.
|
|
* @example
|
|
* // Create many OtpCodes
|
|
* const otpCode = await prisma.otpCode.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends OtpCodeCreateManyArgs>(args?: SelectSubset<T, OtpCodeCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many OtpCodes and returns the data saved in the database.
|
|
* @param {OtpCodeCreateManyAndReturnArgs} args - Arguments to create many OtpCodes.
|
|
* @example
|
|
* // Create many OtpCodes
|
|
* const otpCode = await prisma.otpCode.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many OtpCodes and only return the `id`
|
|
* const otpCodeWithIdOnly = await prisma.otpCode.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 OtpCodeCreateManyAndReturnArgs>(args?: SelectSubset<T, OtpCodeCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a OtpCode.
|
|
* @param {OtpCodeDeleteArgs} args - Arguments to delete one OtpCode.
|
|
* @example
|
|
* // Delete one OtpCode
|
|
* const OtpCode = await prisma.otpCode.delete({
|
|
* where: {
|
|
* // ... filter to delete one OtpCode
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends OtpCodeDeleteArgs>(args: SelectSubset<T, OtpCodeDeleteArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one OtpCode.
|
|
* @param {OtpCodeUpdateArgs} args - Arguments to update one OtpCode.
|
|
* @example
|
|
* // Update one OtpCode
|
|
* const otpCode = await prisma.otpCode.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends OtpCodeUpdateArgs>(args: SelectSubset<T, OtpCodeUpdateArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more OtpCodes.
|
|
* @param {OtpCodeDeleteManyArgs} args - Arguments to filter OtpCodes to delete.
|
|
* @example
|
|
* // Delete a few OtpCodes
|
|
* const { count } = await prisma.otpCode.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends OtpCodeDeleteManyArgs>(args?: SelectSubset<T, OtpCodeDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more OtpCodes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {OtpCodeUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many OtpCodes
|
|
* const otpCode = await prisma.otpCode.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends OtpCodeUpdateManyArgs>(args: SelectSubset<T, OtpCodeUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one OtpCode.
|
|
* @param {OtpCodeUpsertArgs} args - Arguments to update or create a OtpCode.
|
|
* @example
|
|
* // Update or create a OtpCode
|
|
* const otpCode = await prisma.otpCode.upsert({
|
|
* create: {
|
|
* // ... data to create a OtpCode
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the OtpCode we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends OtpCodeUpsertArgs>(args: SelectSubset<T, OtpCodeUpsertArgs<ExtArgs>>): Prisma__OtpCodeClient<$Result.GetResult<Prisma.$OtpCodePayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of OtpCodes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {OtpCodeCountArgs} args - Arguments to filter OtpCodes to count.
|
|
* @example
|
|
* // Count the number of OtpCodes
|
|
* const count = await prisma.otpCode.count({
|
|
* where: {
|
|
* // ... the filter for the OtpCodes we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends OtpCodeCountArgs>(
|
|
args?: Subset<T, OtpCodeCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], OtpCodeCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a OtpCode.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {OtpCodeAggregateArgs} 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 OtpCodeAggregateArgs>(args: Subset<T, OtpCodeAggregateArgs>): Prisma.PrismaPromise<GetOtpCodeAggregateType<T>>
|
|
|
|
/**
|
|
* Group by OtpCode.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {OtpCodeGroupByArgs} 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 OtpCodeGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: OtpCodeGroupByArgs['orderBy'] }
|
|
: { orderBy?: OtpCodeGroupByArgs['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, OtpCodeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetOtpCodeGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the OtpCode model
|
|
*/
|
|
readonly fields: OtpCodeFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for OtpCode.
|
|
* 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__OtpCodeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends OtpCode$userArgs<ExtArgs> = {}>(args?: Subset<T, OtpCode$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
|
|
/**
|
|
* 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 OtpCode model
|
|
*/
|
|
interface OtpCodeFieldRefs {
|
|
readonly id: FieldRef<"OtpCode", 'String'>
|
|
readonly mobile: FieldRef<"OtpCode", 'String'>
|
|
readonly code: FieldRef<"OtpCode", 'String'>
|
|
readonly userId: FieldRef<"OtpCode", 'String'>
|
|
readonly attempts: FieldRef<"OtpCode", 'Int'>
|
|
readonly consumed: FieldRef<"OtpCode", 'Boolean'>
|
|
readonly expiresAt: FieldRef<"OtpCode", 'DateTime'>
|
|
readonly createdAt: FieldRef<"OtpCode", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* OtpCode findUnique
|
|
*/
|
|
export type OtpCodeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which OtpCode to fetch.
|
|
*/
|
|
where: OtpCodeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode findUniqueOrThrow
|
|
*/
|
|
export type OtpCodeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which OtpCode to fetch.
|
|
*/
|
|
where: OtpCodeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode findFirst
|
|
*/
|
|
export type OtpCodeFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which OtpCode to fetch.
|
|
*/
|
|
where?: OtpCodeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of OtpCodes to fetch.
|
|
*/
|
|
orderBy?: OtpCodeOrderByWithRelationInput | OtpCodeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for OtpCodes.
|
|
*/
|
|
cursor?: OtpCodeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` OtpCodes 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` OtpCodes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of OtpCodes.
|
|
*/
|
|
distinct?: OtpCodeScalarFieldEnum | OtpCodeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* OtpCode findFirstOrThrow
|
|
*/
|
|
export type OtpCodeFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which OtpCode to fetch.
|
|
*/
|
|
where?: OtpCodeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of OtpCodes to fetch.
|
|
*/
|
|
orderBy?: OtpCodeOrderByWithRelationInput | OtpCodeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for OtpCodes.
|
|
*/
|
|
cursor?: OtpCodeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` OtpCodes 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` OtpCodes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of OtpCodes.
|
|
*/
|
|
distinct?: OtpCodeScalarFieldEnum | OtpCodeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* OtpCode findMany
|
|
*/
|
|
export type OtpCodeFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which OtpCodes to fetch.
|
|
*/
|
|
where?: OtpCodeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of OtpCodes to fetch.
|
|
*/
|
|
orderBy?: OtpCodeOrderByWithRelationInput | OtpCodeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing OtpCodes.
|
|
*/
|
|
cursor?: OtpCodeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` OtpCodes 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` OtpCodes.
|
|
*/
|
|
skip?: number
|
|
distinct?: OtpCodeScalarFieldEnum | OtpCodeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* OtpCode create
|
|
*/
|
|
export type OtpCodeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a OtpCode.
|
|
*/
|
|
data: XOR<OtpCodeCreateInput, OtpCodeUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* OtpCode createMany
|
|
*/
|
|
export type OtpCodeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many OtpCodes.
|
|
*/
|
|
data: OtpCodeCreateManyInput | OtpCodeCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* OtpCode createManyAndReturn
|
|
*/
|
|
export type OtpCodeCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many OtpCodes.
|
|
*/
|
|
data: OtpCodeCreateManyInput | OtpCodeCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* OtpCode update
|
|
*/
|
|
export type OtpCodeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a OtpCode.
|
|
*/
|
|
data: XOR<OtpCodeUpdateInput, OtpCodeUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which OtpCode to update.
|
|
*/
|
|
where: OtpCodeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode updateMany
|
|
*/
|
|
export type OtpCodeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update OtpCodes.
|
|
*/
|
|
data: XOR<OtpCodeUpdateManyMutationInput, OtpCodeUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which OtpCodes to update
|
|
*/
|
|
where?: OtpCodeWhereInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode upsert
|
|
*/
|
|
export type OtpCodeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the OtpCode to update in case it exists.
|
|
*/
|
|
where: OtpCodeWhereUniqueInput
|
|
/**
|
|
* In case the OtpCode found by the `where` argument doesn't exist, create a new OtpCode with this data.
|
|
*/
|
|
create: XOR<OtpCodeCreateInput, OtpCodeUncheckedCreateInput>
|
|
/**
|
|
* In case the OtpCode was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<OtpCodeUpdateInput, OtpCodeUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* OtpCode delete
|
|
*/
|
|
export type OtpCodeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which OtpCode to delete.
|
|
*/
|
|
where: OtpCodeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode deleteMany
|
|
*/
|
|
export type OtpCodeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which OtpCodes to delete
|
|
*/
|
|
where?: OtpCodeWhereInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode.user
|
|
*/
|
|
export type OtpCode$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
/**
|
|
* OtpCode without action
|
|
*/
|
|
export type OtpCodeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the OtpCode
|
|
*/
|
|
select?: OtpCodeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: OtpCodeInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Campaign
|
|
*/
|
|
|
|
export type AggregateCampaign = {
|
|
_count: CampaignCountAggregateOutputType | null
|
|
_avg: CampaignAvgAggregateOutputType | null
|
|
_sum: CampaignSumAggregateOutputType | null
|
|
_min: CampaignMinAggregateOutputType | null
|
|
_max: CampaignMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type CampaignAvgAggregateOutputType = {
|
|
defaultChances: number | null
|
|
}
|
|
|
|
export type CampaignSumAggregateOutputType = {
|
|
defaultChances: number | null
|
|
}
|
|
|
|
export type CampaignMinAggregateOutputType = {
|
|
id: string | null
|
|
title: string | null
|
|
slug: string | null
|
|
description: string | null
|
|
image: string | null
|
|
banner: string | null
|
|
logo: string | null
|
|
startAt: Date | null
|
|
endAt: Date | null
|
|
status: $Enums.CampaignStatus | null
|
|
defaultChances: number | null
|
|
rules: string | null
|
|
ctaText: string | null
|
|
wheelDesign: $Enums.WheelDesign | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type CampaignMaxAggregateOutputType = {
|
|
id: string | null
|
|
title: string | null
|
|
slug: string | null
|
|
description: string | null
|
|
image: string | null
|
|
banner: string | null
|
|
logo: string | null
|
|
startAt: Date | null
|
|
endAt: Date | null
|
|
status: $Enums.CampaignStatus | null
|
|
defaultChances: number | null
|
|
rules: string | null
|
|
ctaText: string | null
|
|
wheelDesign: $Enums.WheelDesign | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type CampaignCountAggregateOutputType = {
|
|
id: number
|
|
title: number
|
|
slug: number
|
|
description: number
|
|
image: number
|
|
banner: number
|
|
logo: number
|
|
startAt: number
|
|
endAt: number
|
|
status: number
|
|
defaultChances: number
|
|
rules: number
|
|
ctaText: number
|
|
wheelDesign: number
|
|
settings: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type CampaignAvgAggregateInputType = {
|
|
defaultChances?: true
|
|
}
|
|
|
|
export type CampaignSumAggregateInputType = {
|
|
defaultChances?: true
|
|
}
|
|
|
|
export type CampaignMinAggregateInputType = {
|
|
id?: true
|
|
title?: true
|
|
slug?: true
|
|
description?: true
|
|
image?: true
|
|
banner?: true
|
|
logo?: true
|
|
startAt?: true
|
|
endAt?: true
|
|
status?: true
|
|
defaultChances?: true
|
|
rules?: true
|
|
ctaText?: true
|
|
wheelDesign?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type CampaignMaxAggregateInputType = {
|
|
id?: true
|
|
title?: true
|
|
slug?: true
|
|
description?: true
|
|
image?: true
|
|
banner?: true
|
|
logo?: true
|
|
startAt?: true
|
|
endAt?: true
|
|
status?: true
|
|
defaultChances?: true
|
|
rules?: true
|
|
ctaText?: true
|
|
wheelDesign?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type CampaignCountAggregateInputType = {
|
|
id?: true
|
|
title?: true
|
|
slug?: true
|
|
description?: true
|
|
image?: true
|
|
banner?: true
|
|
logo?: true
|
|
startAt?: true
|
|
endAt?: true
|
|
status?: true
|
|
defaultChances?: true
|
|
rules?: true
|
|
ctaText?: true
|
|
wheelDesign?: true
|
|
settings?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type CampaignAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Campaign to aggregate.
|
|
*/
|
|
where?: CampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Campaigns to fetch.
|
|
*/
|
|
orderBy?: CampaignOrderByWithRelationInput | CampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: CampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Campaigns 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` Campaigns.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Campaigns
|
|
**/
|
|
_count?: true | CampaignCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: CampaignAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: CampaignSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: CampaignMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: CampaignMaxAggregateInputType
|
|
}
|
|
|
|
export type GetCampaignAggregateType<T extends CampaignAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateCampaign]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateCampaign[P]>
|
|
: GetScalarType<T[P], AggregateCampaign[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type CampaignGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: CampaignWhereInput
|
|
orderBy?: CampaignOrderByWithAggregationInput | CampaignOrderByWithAggregationInput[]
|
|
by: CampaignScalarFieldEnum[] | CampaignScalarFieldEnum
|
|
having?: CampaignScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: CampaignCountAggregateInputType | true
|
|
_avg?: CampaignAvgAggregateInputType
|
|
_sum?: CampaignSumAggregateInputType
|
|
_min?: CampaignMinAggregateInputType
|
|
_max?: CampaignMaxAggregateInputType
|
|
}
|
|
|
|
export type CampaignGroupByOutputType = {
|
|
id: string
|
|
title: string
|
|
slug: string
|
|
description: string | null
|
|
image: string | null
|
|
banner: string | null
|
|
logo: string | null
|
|
startAt: Date
|
|
endAt: Date
|
|
status: $Enums.CampaignStatus
|
|
defaultChances: number
|
|
rules: string | null
|
|
ctaText: string | null
|
|
wheelDesign: $Enums.WheelDesign
|
|
settings: JsonValue | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: CampaignCountAggregateOutputType | null
|
|
_avg: CampaignAvgAggregateOutputType | null
|
|
_sum: CampaignSumAggregateOutputType | null
|
|
_min: CampaignMinAggregateOutputType | null
|
|
_max: CampaignMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetCampaignGroupByPayload<T extends CampaignGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<CampaignGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof CampaignGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], CampaignGroupByOutputType[P]>
|
|
: GetScalarType<T[P], CampaignGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type CampaignSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
title?: boolean
|
|
slug?: boolean
|
|
description?: boolean
|
|
image?: boolean
|
|
banner?: boolean
|
|
logo?: boolean
|
|
startAt?: boolean
|
|
endAt?: boolean
|
|
status?: boolean
|
|
defaultChances?: boolean
|
|
rules?: boolean
|
|
ctaText?: boolean
|
|
wheelDesign?: boolean
|
|
settings?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
prizes?: boolean | Campaign$prizesArgs<ExtArgs>
|
|
userCampaigns?: boolean | Campaign$userCampaignsArgs<ExtArgs>
|
|
chanceTxns?: boolean | Campaign$chanceTxnsArgs<ExtArgs>
|
|
spins?: boolean | Campaign$spinsArgs<ExtArgs>
|
|
userPrizes?: boolean | Campaign$userPrizesArgs<ExtArgs>
|
|
_count?: boolean | CampaignCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["campaign"]>
|
|
|
|
export type CampaignSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
title?: boolean
|
|
slug?: boolean
|
|
description?: boolean
|
|
image?: boolean
|
|
banner?: boolean
|
|
logo?: boolean
|
|
startAt?: boolean
|
|
endAt?: boolean
|
|
status?: boolean
|
|
defaultChances?: boolean
|
|
rules?: boolean
|
|
ctaText?: boolean
|
|
wheelDesign?: boolean
|
|
settings?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["campaign"]>
|
|
|
|
export type CampaignSelectScalar = {
|
|
id?: boolean
|
|
title?: boolean
|
|
slug?: boolean
|
|
description?: boolean
|
|
image?: boolean
|
|
banner?: boolean
|
|
logo?: boolean
|
|
startAt?: boolean
|
|
endAt?: boolean
|
|
status?: boolean
|
|
defaultChances?: boolean
|
|
rules?: boolean
|
|
ctaText?: boolean
|
|
wheelDesign?: boolean
|
|
settings?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type CampaignInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
prizes?: boolean | Campaign$prizesArgs<ExtArgs>
|
|
userCampaigns?: boolean | Campaign$userCampaignsArgs<ExtArgs>
|
|
chanceTxns?: boolean | Campaign$chanceTxnsArgs<ExtArgs>
|
|
spins?: boolean | Campaign$spinsArgs<ExtArgs>
|
|
userPrizes?: boolean | Campaign$userPrizesArgs<ExtArgs>
|
|
_count?: boolean | CampaignCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type CampaignIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $CampaignPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Campaign"
|
|
objects: {
|
|
prizes: Prisma.$PrizePayload<ExtArgs>[]
|
|
userCampaigns: Prisma.$UserCampaignPayload<ExtArgs>[]
|
|
chanceTxns: Prisma.$ChanceTransactionPayload<ExtArgs>[]
|
|
spins: Prisma.$SpinPayload<ExtArgs>[]
|
|
userPrizes: Prisma.$UserPrizePayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
title: string
|
|
slug: string
|
|
description: string | null
|
|
image: string | null
|
|
banner: string | null
|
|
logo: string | null
|
|
startAt: Date
|
|
endAt: Date
|
|
status: $Enums.CampaignStatus
|
|
defaultChances: number
|
|
rules: string | null
|
|
ctaText: string | null
|
|
wheelDesign: $Enums.WheelDesign
|
|
settings: Prisma.JsonValue | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["campaign"]>
|
|
composites: {}
|
|
}
|
|
|
|
type CampaignGetPayload<S extends boolean | null | undefined | CampaignDefaultArgs> = $Result.GetResult<Prisma.$CampaignPayload, S>
|
|
|
|
type CampaignCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<CampaignFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: CampaignCountAggregateInputType | true
|
|
}
|
|
|
|
export interface CampaignDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Campaign'], meta: { name: 'Campaign' } }
|
|
/**
|
|
* Find zero or one Campaign that matches the filter.
|
|
* @param {CampaignFindUniqueArgs} args - Arguments to find a Campaign
|
|
* @example
|
|
* // Get one Campaign
|
|
* const campaign = await prisma.campaign.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends CampaignFindUniqueArgs>(args: SelectSubset<T, CampaignFindUniqueArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one Campaign that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {CampaignFindUniqueOrThrowArgs} args - Arguments to find a Campaign
|
|
* @example
|
|
* // Get one Campaign
|
|
* const campaign = await prisma.campaign.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends CampaignFindUniqueOrThrowArgs>(args: SelectSubset<T, CampaignFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Campaign 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 {CampaignFindFirstArgs} args - Arguments to find a Campaign
|
|
* @example
|
|
* // Get one Campaign
|
|
* const campaign = await prisma.campaign.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends CampaignFindFirstArgs>(args?: SelectSubset<T, CampaignFindFirstArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Campaign 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 {CampaignFindFirstOrThrowArgs} args - Arguments to find a Campaign
|
|
* @example
|
|
* // Get one Campaign
|
|
* const campaign = await prisma.campaign.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends CampaignFindFirstOrThrowArgs>(args?: SelectSubset<T, CampaignFindFirstOrThrowArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more Campaigns 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 {CampaignFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Campaigns
|
|
* const campaigns = await prisma.campaign.findMany()
|
|
*
|
|
* // Get first 10 Campaigns
|
|
* const campaigns = await prisma.campaign.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const campaignWithIdOnly = await prisma.campaign.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends CampaignFindManyArgs>(args?: SelectSubset<T, CampaignFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a Campaign.
|
|
* @param {CampaignCreateArgs} args - Arguments to create a Campaign.
|
|
* @example
|
|
* // Create one Campaign
|
|
* const Campaign = await prisma.campaign.create({
|
|
* data: {
|
|
* // ... data to create a Campaign
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends CampaignCreateArgs>(args: SelectSubset<T, CampaignCreateArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many Campaigns.
|
|
* @param {CampaignCreateManyArgs} args - Arguments to create many Campaigns.
|
|
* @example
|
|
* // Create many Campaigns
|
|
* const campaign = await prisma.campaign.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends CampaignCreateManyArgs>(args?: SelectSubset<T, CampaignCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Campaigns and returns the data saved in the database.
|
|
* @param {CampaignCreateManyAndReturnArgs} args - Arguments to create many Campaigns.
|
|
* @example
|
|
* // Create many Campaigns
|
|
* const campaign = await prisma.campaign.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Campaigns and only return the `id`
|
|
* const campaignWithIdOnly = await prisma.campaign.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 CampaignCreateManyAndReturnArgs>(args?: SelectSubset<T, CampaignCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a Campaign.
|
|
* @param {CampaignDeleteArgs} args - Arguments to delete one Campaign.
|
|
* @example
|
|
* // Delete one Campaign
|
|
* const Campaign = await prisma.campaign.delete({
|
|
* where: {
|
|
* // ... filter to delete one Campaign
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends CampaignDeleteArgs>(args: SelectSubset<T, CampaignDeleteArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one Campaign.
|
|
* @param {CampaignUpdateArgs} args - Arguments to update one Campaign.
|
|
* @example
|
|
* // Update one Campaign
|
|
* const campaign = await prisma.campaign.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends CampaignUpdateArgs>(args: SelectSubset<T, CampaignUpdateArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more Campaigns.
|
|
* @param {CampaignDeleteManyArgs} args - Arguments to filter Campaigns to delete.
|
|
* @example
|
|
* // Delete a few Campaigns
|
|
* const { count } = await prisma.campaign.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends CampaignDeleteManyArgs>(args?: SelectSubset<T, CampaignDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Campaigns.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CampaignUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Campaigns
|
|
* const campaign = await prisma.campaign.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends CampaignUpdateManyArgs>(args: SelectSubset<T, CampaignUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one Campaign.
|
|
* @param {CampaignUpsertArgs} args - Arguments to update or create a Campaign.
|
|
* @example
|
|
* // Update or create a Campaign
|
|
* const campaign = await prisma.campaign.upsert({
|
|
* create: {
|
|
* // ... data to create a Campaign
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Campaign we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends CampaignUpsertArgs>(args: SelectSubset<T, CampaignUpsertArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of Campaigns.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CampaignCountArgs} args - Arguments to filter Campaigns to count.
|
|
* @example
|
|
* // Count the number of Campaigns
|
|
* const count = await prisma.campaign.count({
|
|
* where: {
|
|
* // ... the filter for the Campaigns we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends CampaignCountArgs>(
|
|
args?: Subset<T, CampaignCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], CampaignCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Campaign.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CampaignAggregateArgs} 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 CampaignAggregateArgs>(args: Subset<T, CampaignAggregateArgs>): Prisma.PrismaPromise<GetCampaignAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Campaign.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CampaignGroupByArgs} 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 CampaignGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: CampaignGroupByArgs['orderBy'] }
|
|
: { orderBy?: CampaignGroupByArgs['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, CampaignGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCampaignGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Campaign model
|
|
*/
|
|
readonly fields: CampaignFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Campaign.
|
|
* 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__CampaignClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
prizes<T extends Campaign$prizesArgs<ExtArgs> = {}>(args?: Subset<T, Campaign$prizesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findMany"> | Null>
|
|
userCampaigns<T extends Campaign$userCampaignsArgs<ExtArgs> = {}>(args?: Subset<T, Campaign$userCampaignsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findMany"> | Null>
|
|
chanceTxns<T extends Campaign$chanceTxnsArgs<ExtArgs> = {}>(args?: Subset<T, Campaign$chanceTxnsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findMany"> | Null>
|
|
spins<T extends Campaign$spinsArgs<ExtArgs> = {}>(args?: Subset<T, Campaign$spinsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findMany"> | Null>
|
|
userPrizes<T extends Campaign$userPrizesArgs<ExtArgs> = {}>(args?: Subset<T, Campaign$userPrizesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findMany"> | 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 Campaign model
|
|
*/
|
|
interface CampaignFieldRefs {
|
|
readonly id: FieldRef<"Campaign", 'String'>
|
|
readonly title: FieldRef<"Campaign", 'String'>
|
|
readonly slug: FieldRef<"Campaign", 'String'>
|
|
readonly description: FieldRef<"Campaign", 'String'>
|
|
readonly image: FieldRef<"Campaign", 'String'>
|
|
readonly banner: FieldRef<"Campaign", 'String'>
|
|
readonly logo: FieldRef<"Campaign", 'String'>
|
|
readonly startAt: FieldRef<"Campaign", 'DateTime'>
|
|
readonly endAt: FieldRef<"Campaign", 'DateTime'>
|
|
readonly status: FieldRef<"Campaign", 'CampaignStatus'>
|
|
readonly defaultChances: FieldRef<"Campaign", 'Int'>
|
|
readonly rules: FieldRef<"Campaign", 'String'>
|
|
readonly ctaText: FieldRef<"Campaign", 'String'>
|
|
readonly wheelDesign: FieldRef<"Campaign", 'WheelDesign'>
|
|
readonly settings: FieldRef<"Campaign", 'Json'>
|
|
readonly createdAt: FieldRef<"Campaign", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Campaign", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Campaign findUnique
|
|
*/
|
|
export type CampaignFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Campaign to fetch.
|
|
*/
|
|
where: CampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Campaign findUniqueOrThrow
|
|
*/
|
|
export type CampaignFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Campaign to fetch.
|
|
*/
|
|
where: CampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Campaign findFirst
|
|
*/
|
|
export type CampaignFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Campaign to fetch.
|
|
*/
|
|
where?: CampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Campaigns to fetch.
|
|
*/
|
|
orderBy?: CampaignOrderByWithRelationInput | CampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Campaigns.
|
|
*/
|
|
cursor?: CampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Campaigns 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` Campaigns.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Campaigns.
|
|
*/
|
|
distinct?: CampaignScalarFieldEnum | CampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign findFirstOrThrow
|
|
*/
|
|
export type CampaignFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Campaign to fetch.
|
|
*/
|
|
where?: CampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Campaigns to fetch.
|
|
*/
|
|
orderBy?: CampaignOrderByWithRelationInput | CampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Campaigns.
|
|
*/
|
|
cursor?: CampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Campaigns 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` Campaigns.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Campaigns.
|
|
*/
|
|
distinct?: CampaignScalarFieldEnum | CampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign findMany
|
|
*/
|
|
export type CampaignFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Campaigns to fetch.
|
|
*/
|
|
where?: CampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Campaigns to fetch.
|
|
*/
|
|
orderBy?: CampaignOrderByWithRelationInput | CampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Campaigns.
|
|
*/
|
|
cursor?: CampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Campaigns 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` Campaigns.
|
|
*/
|
|
skip?: number
|
|
distinct?: CampaignScalarFieldEnum | CampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign create
|
|
*/
|
|
export type CampaignCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Campaign.
|
|
*/
|
|
data: XOR<CampaignCreateInput, CampaignUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Campaign createMany
|
|
*/
|
|
export type CampaignCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Campaigns.
|
|
*/
|
|
data: CampaignCreateManyInput | CampaignCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Campaign createManyAndReturn
|
|
*/
|
|
export type CampaignCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Campaigns.
|
|
*/
|
|
data: CampaignCreateManyInput | CampaignCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Campaign update
|
|
*/
|
|
export type CampaignUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Campaign.
|
|
*/
|
|
data: XOR<CampaignUpdateInput, CampaignUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Campaign to update.
|
|
*/
|
|
where: CampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Campaign updateMany
|
|
*/
|
|
export type CampaignUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Campaigns.
|
|
*/
|
|
data: XOR<CampaignUpdateManyMutationInput, CampaignUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Campaigns to update
|
|
*/
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
/**
|
|
* Campaign upsert
|
|
*/
|
|
export type CampaignUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Campaign to update in case it exists.
|
|
*/
|
|
where: CampaignWhereUniqueInput
|
|
/**
|
|
* In case the Campaign found by the `where` argument doesn't exist, create a new Campaign with this data.
|
|
*/
|
|
create: XOR<CampaignCreateInput, CampaignUncheckedCreateInput>
|
|
/**
|
|
* In case the Campaign was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<CampaignUpdateInput, CampaignUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Campaign delete
|
|
*/
|
|
export type CampaignDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Campaign to delete.
|
|
*/
|
|
where: CampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Campaign deleteMany
|
|
*/
|
|
export type CampaignDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Campaigns to delete
|
|
*/
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
/**
|
|
* Campaign.prizes
|
|
*/
|
|
export type Campaign$prizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
where?: PrizeWhereInput
|
|
orderBy?: PrizeOrderByWithRelationInput | PrizeOrderByWithRelationInput[]
|
|
cursor?: PrizeWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: PrizeScalarFieldEnum | PrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign.userCampaigns
|
|
*/
|
|
export type Campaign$userCampaignsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
where?: UserCampaignWhereInput
|
|
orderBy?: UserCampaignOrderByWithRelationInput | UserCampaignOrderByWithRelationInput[]
|
|
cursor?: UserCampaignWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: UserCampaignScalarFieldEnum | UserCampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign.chanceTxns
|
|
*/
|
|
export type Campaign$chanceTxnsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
where?: ChanceTransactionWhereInput
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: ChanceTransactionScalarFieldEnum | ChanceTransactionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign.spins
|
|
*/
|
|
export type Campaign$spinsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
where?: SpinWhereInput
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
cursor?: SpinWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SpinScalarFieldEnum | SpinScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign.userPrizes
|
|
*/
|
|
export type Campaign$userPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
where?: UserPrizeWhereInput
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: UserPrizeScalarFieldEnum | UserPrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Campaign without action
|
|
*/
|
|
export type CampaignDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Campaign
|
|
*/
|
|
select?: CampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: CampaignInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Prize
|
|
*/
|
|
|
|
export type AggregatePrize = {
|
|
_count: PrizeCountAggregateOutputType | null
|
|
_avg: PrizeAvgAggregateOutputType | null
|
|
_sum: PrizeSumAggregateOutputType | null
|
|
_min: PrizeMinAggregateOutputType | null
|
|
_max: PrizeMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type PrizeAvgAggregateOutputType = {
|
|
initialStock: number | null
|
|
remainingStock: number | null
|
|
weight: number | null
|
|
sortOrder: number | null
|
|
}
|
|
|
|
export type PrizeSumAggregateOutputType = {
|
|
initialStock: number | null
|
|
remainingStock: number | null
|
|
weight: number | null
|
|
sortOrder: number | null
|
|
}
|
|
|
|
export type PrizeMinAggregateOutputType = {
|
|
id: string | null
|
|
campaignId: string | null
|
|
title: string | null
|
|
description: string | null
|
|
image: string | null
|
|
type: $Enums.PrizeType | null
|
|
stockType: $Enums.StockType | null
|
|
initialStock: number | null
|
|
remainingStock: number | null
|
|
weight: number | null
|
|
status: $Enums.PrizeStatus | null
|
|
sortOrder: number | null
|
|
segmentColor: string | null
|
|
expiresAt: Date | null
|
|
smsTemplate: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type PrizeMaxAggregateOutputType = {
|
|
id: string | null
|
|
campaignId: string | null
|
|
title: string | null
|
|
description: string | null
|
|
image: string | null
|
|
type: $Enums.PrizeType | null
|
|
stockType: $Enums.StockType | null
|
|
initialStock: number | null
|
|
remainingStock: number | null
|
|
weight: number | null
|
|
status: $Enums.PrizeStatus | null
|
|
sortOrder: number | null
|
|
segmentColor: string | null
|
|
expiresAt: Date | null
|
|
smsTemplate: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type PrizeCountAggregateOutputType = {
|
|
id: number
|
|
campaignId: number
|
|
title: number
|
|
description: number
|
|
image: number
|
|
type: number
|
|
stockType: number
|
|
initialStock: number
|
|
remainingStock: number
|
|
weight: number
|
|
status: number
|
|
sortOrder: number
|
|
segmentColor: number
|
|
expiresAt: number
|
|
smsTemplate: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type PrizeAvgAggregateInputType = {
|
|
initialStock?: true
|
|
remainingStock?: true
|
|
weight?: true
|
|
sortOrder?: true
|
|
}
|
|
|
|
export type PrizeSumAggregateInputType = {
|
|
initialStock?: true
|
|
remainingStock?: true
|
|
weight?: true
|
|
sortOrder?: true
|
|
}
|
|
|
|
export type PrizeMinAggregateInputType = {
|
|
id?: true
|
|
campaignId?: true
|
|
title?: true
|
|
description?: true
|
|
image?: true
|
|
type?: true
|
|
stockType?: true
|
|
initialStock?: true
|
|
remainingStock?: true
|
|
weight?: true
|
|
status?: true
|
|
sortOrder?: true
|
|
segmentColor?: true
|
|
expiresAt?: true
|
|
smsTemplate?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type PrizeMaxAggregateInputType = {
|
|
id?: true
|
|
campaignId?: true
|
|
title?: true
|
|
description?: true
|
|
image?: true
|
|
type?: true
|
|
stockType?: true
|
|
initialStock?: true
|
|
remainingStock?: true
|
|
weight?: true
|
|
status?: true
|
|
sortOrder?: true
|
|
segmentColor?: true
|
|
expiresAt?: true
|
|
smsTemplate?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type PrizeCountAggregateInputType = {
|
|
id?: true
|
|
campaignId?: true
|
|
title?: true
|
|
description?: true
|
|
image?: true
|
|
type?: true
|
|
stockType?: true
|
|
initialStock?: true
|
|
remainingStock?: true
|
|
weight?: true
|
|
status?: true
|
|
sortOrder?: true
|
|
segmentColor?: true
|
|
expiresAt?: true
|
|
smsTemplate?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type PrizeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Prize to aggregate.
|
|
*/
|
|
where?: PrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Prizes to fetch.
|
|
*/
|
|
orderBy?: PrizeOrderByWithRelationInput | PrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: PrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Prizes 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` Prizes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Prizes
|
|
**/
|
|
_count?: true | PrizeCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: PrizeAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: PrizeSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: PrizeMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: PrizeMaxAggregateInputType
|
|
}
|
|
|
|
export type GetPrizeAggregateType<T extends PrizeAggregateArgs> = {
|
|
[P in keyof T & keyof AggregatePrize]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregatePrize[P]>
|
|
: GetScalarType<T[P], AggregatePrize[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type PrizeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: PrizeWhereInput
|
|
orderBy?: PrizeOrderByWithAggregationInput | PrizeOrderByWithAggregationInput[]
|
|
by: PrizeScalarFieldEnum[] | PrizeScalarFieldEnum
|
|
having?: PrizeScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: PrizeCountAggregateInputType | true
|
|
_avg?: PrizeAvgAggregateInputType
|
|
_sum?: PrizeSumAggregateInputType
|
|
_min?: PrizeMinAggregateInputType
|
|
_max?: PrizeMaxAggregateInputType
|
|
}
|
|
|
|
export type PrizeGroupByOutputType = {
|
|
id: string
|
|
campaignId: string
|
|
title: string
|
|
description: string | null
|
|
image: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock: number | null
|
|
remainingStock: number | null
|
|
weight: number
|
|
status: $Enums.PrizeStatus
|
|
sortOrder: number
|
|
segmentColor: string
|
|
expiresAt: Date | null
|
|
smsTemplate: string | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: PrizeCountAggregateOutputType | null
|
|
_avg: PrizeAvgAggregateOutputType | null
|
|
_sum: PrizeSumAggregateOutputType | null
|
|
_min: PrizeMinAggregateOutputType | null
|
|
_max: PrizeMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetPrizeGroupByPayload<T extends PrizeGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<PrizeGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof PrizeGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], PrizeGroupByOutputType[P]>
|
|
: GetScalarType<T[P], PrizeGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type PrizeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
campaignId?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
image?: boolean
|
|
type?: boolean
|
|
stockType?: boolean
|
|
initialStock?: boolean
|
|
remainingStock?: boolean
|
|
weight?: boolean
|
|
status?: boolean
|
|
sortOrder?: boolean
|
|
segmentColor?: boolean
|
|
expiresAt?: boolean
|
|
smsTemplate?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
spins?: boolean | Prize$spinsArgs<ExtArgs>
|
|
userPrizes?: boolean | Prize$userPrizesArgs<ExtArgs>
|
|
_count?: boolean | PrizeCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["prize"]>
|
|
|
|
export type PrizeSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
campaignId?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
image?: boolean
|
|
type?: boolean
|
|
stockType?: boolean
|
|
initialStock?: boolean
|
|
remainingStock?: boolean
|
|
weight?: boolean
|
|
status?: boolean
|
|
sortOrder?: boolean
|
|
segmentColor?: boolean
|
|
expiresAt?: boolean
|
|
smsTemplate?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["prize"]>
|
|
|
|
export type PrizeSelectScalar = {
|
|
id?: boolean
|
|
campaignId?: boolean
|
|
title?: boolean
|
|
description?: boolean
|
|
image?: boolean
|
|
type?: boolean
|
|
stockType?: boolean
|
|
initialStock?: boolean
|
|
remainingStock?: boolean
|
|
weight?: boolean
|
|
status?: boolean
|
|
sortOrder?: boolean
|
|
segmentColor?: boolean
|
|
expiresAt?: boolean
|
|
smsTemplate?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type PrizeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
spins?: boolean | Prize$spinsArgs<ExtArgs>
|
|
userPrizes?: boolean | Prize$userPrizesArgs<ExtArgs>
|
|
_count?: boolean | PrizeCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type PrizeIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $PrizePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Prize"
|
|
objects: {
|
|
campaign: Prisma.$CampaignPayload<ExtArgs>
|
|
spins: Prisma.$SpinPayload<ExtArgs>[]
|
|
userPrizes: Prisma.$UserPrizePayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
campaignId: string
|
|
title: string
|
|
description: string | null
|
|
image: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock: number | null
|
|
remainingStock: number | null
|
|
weight: number
|
|
status: $Enums.PrizeStatus
|
|
sortOrder: number
|
|
segmentColor: string
|
|
expiresAt: Date | null
|
|
smsTemplate: string | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["prize"]>
|
|
composites: {}
|
|
}
|
|
|
|
type PrizeGetPayload<S extends boolean | null | undefined | PrizeDefaultArgs> = $Result.GetResult<Prisma.$PrizePayload, S>
|
|
|
|
type PrizeCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<PrizeFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: PrizeCountAggregateInputType | true
|
|
}
|
|
|
|
export interface PrizeDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Prize'], meta: { name: 'Prize' } }
|
|
/**
|
|
* Find zero or one Prize that matches the filter.
|
|
* @param {PrizeFindUniqueArgs} args - Arguments to find a Prize
|
|
* @example
|
|
* // Get one Prize
|
|
* const prize = await prisma.prize.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends PrizeFindUniqueArgs>(args: SelectSubset<T, PrizeFindUniqueArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one Prize that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {PrizeFindUniqueOrThrowArgs} args - Arguments to find a Prize
|
|
* @example
|
|
* // Get one Prize
|
|
* const prize = await prisma.prize.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends PrizeFindUniqueOrThrowArgs>(args: SelectSubset<T, PrizeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Prize 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 {PrizeFindFirstArgs} args - Arguments to find a Prize
|
|
* @example
|
|
* // Get one Prize
|
|
* const prize = await prisma.prize.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends PrizeFindFirstArgs>(args?: SelectSubset<T, PrizeFindFirstArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Prize 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 {PrizeFindFirstOrThrowArgs} args - Arguments to find a Prize
|
|
* @example
|
|
* // Get one Prize
|
|
* const prize = await prisma.prize.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends PrizeFindFirstOrThrowArgs>(args?: SelectSubset<T, PrizeFindFirstOrThrowArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more Prizes 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 {PrizeFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Prizes
|
|
* const prizes = await prisma.prize.findMany()
|
|
*
|
|
* // Get first 10 Prizes
|
|
* const prizes = await prisma.prize.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const prizeWithIdOnly = await prisma.prize.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends PrizeFindManyArgs>(args?: SelectSubset<T, PrizeFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a Prize.
|
|
* @param {PrizeCreateArgs} args - Arguments to create a Prize.
|
|
* @example
|
|
* // Create one Prize
|
|
* const Prize = await prisma.prize.create({
|
|
* data: {
|
|
* // ... data to create a Prize
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends PrizeCreateArgs>(args: SelectSubset<T, PrizeCreateArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many Prizes.
|
|
* @param {PrizeCreateManyArgs} args - Arguments to create many Prizes.
|
|
* @example
|
|
* // Create many Prizes
|
|
* const prize = await prisma.prize.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends PrizeCreateManyArgs>(args?: SelectSubset<T, PrizeCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Prizes and returns the data saved in the database.
|
|
* @param {PrizeCreateManyAndReturnArgs} args - Arguments to create many Prizes.
|
|
* @example
|
|
* // Create many Prizes
|
|
* const prize = await prisma.prize.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Prizes and only return the `id`
|
|
* const prizeWithIdOnly = await prisma.prize.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 PrizeCreateManyAndReturnArgs>(args?: SelectSubset<T, PrizeCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a Prize.
|
|
* @param {PrizeDeleteArgs} args - Arguments to delete one Prize.
|
|
* @example
|
|
* // Delete one Prize
|
|
* const Prize = await prisma.prize.delete({
|
|
* where: {
|
|
* // ... filter to delete one Prize
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends PrizeDeleteArgs>(args: SelectSubset<T, PrizeDeleteArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one Prize.
|
|
* @param {PrizeUpdateArgs} args - Arguments to update one Prize.
|
|
* @example
|
|
* // Update one Prize
|
|
* const prize = await prisma.prize.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends PrizeUpdateArgs>(args: SelectSubset<T, PrizeUpdateArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more Prizes.
|
|
* @param {PrizeDeleteManyArgs} args - Arguments to filter Prizes to delete.
|
|
* @example
|
|
* // Delete a few Prizes
|
|
* const { count } = await prisma.prize.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends PrizeDeleteManyArgs>(args?: SelectSubset<T, PrizeDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Prizes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PrizeUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Prizes
|
|
* const prize = await prisma.prize.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends PrizeUpdateManyArgs>(args: SelectSubset<T, PrizeUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one Prize.
|
|
* @param {PrizeUpsertArgs} args - Arguments to update or create a Prize.
|
|
* @example
|
|
* // Update or create a Prize
|
|
* const prize = await prisma.prize.upsert({
|
|
* create: {
|
|
* // ... data to create a Prize
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Prize we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends PrizeUpsertArgs>(args: SelectSubset<T, PrizeUpsertArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of Prizes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PrizeCountArgs} args - Arguments to filter Prizes to count.
|
|
* @example
|
|
* // Count the number of Prizes
|
|
* const count = await prisma.prize.count({
|
|
* where: {
|
|
* // ... the filter for the Prizes we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends PrizeCountArgs>(
|
|
args?: Subset<T, PrizeCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], PrizeCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Prize.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PrizeAggregateArgs} 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 PrizeAggregateArgs>(args: Subset<T, PrizeAggregateArgs>): Prisma.PrismaPromise<GetPrizeAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Prize.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PrizeGroupByArgs} 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 PrizeGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: PrizeGroupByArgs['orderBy'] }
|
|
: { orderBy?: PrizeGroupByArgs['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, PrizeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPrizeGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Prize model
|
|
*/
|
|
readonly fields: PrizeFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Prize.
|
|
* 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__PrizeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
campaign<T extends CampaignDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CampaignDefaultArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
spins<T extends Prize$spinsArgs<ExtArgs> = {}>(args?: Subset<T, Prize$spinsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findMany"> | Null>
|
|
userPrizes<T extends Prize$userPrizesArgs<ExtArgs> = {}>(args?: Subset<T, Prize$userPrizesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findMany"> | 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 Prize model
|
|
*/
|
|
interface PrizeFieldRefs {
|
|
readonly id: FieldRef<"Prize", 'String'>
|
|
readonly campaignId: FieldRef<"Prize", 'String'>
|
|
readonly title: FieldRef<"Prize", 'String'>
|
|
readonly description: FieldRef<"Prize", 'String'>
|
|
readonly image: FieldRef<"Prize", 'String'>
|
|
readonly type: FieldRef<"Prize", 'PrizeType'>
|
|
readonly stockType: FieldRef<"Prize", 'StockType'>
|
|
readonly initialStock: FieldRef<"Prize", 'Int'>
|
|
readonly remainingStock: FieldRef<"Prize", 'Int'>
|
|
readonly weight: FieldRef<"Prize", 'Int'>
|
|
readonly status: FieldRef<"Prize", 'PrizeStatus'>
|
|
readonly sortOrder: FieldRef<"Prize", 'Int'>
|
|
readonly segmentColor: FieldRef<"Prize", 'String'>
|
|
readonly expiresAt: FieldRef<"Prize", 'DateTime'>
|
|
readonly smsTemplate: FieldRef<"Prize", 'String'>
|
|
readonly createdAt: FieldRef<"Prize", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Prize", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Prize findUnique
|
|
*/
|
|
export type PrizeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Prize to fetch.
|
|
*/
|
|
where: PrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Prize findUniqueOrThrow
|
|
*/
|
|
export type PrizeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Prize to fetch.
|
|
*/
|
|
where: PrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Prize findFirst
|
|
*/
|
|
export type PrizeFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Prize to fetch.
|
|
*/
|
|
where?: PrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Prizes to fetch.
|
|
*/
|
|
orderBy?: PrizeOrderByWithRelationInput | PrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Prizes.
|
|
*/
|
|
cursor?: PrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Prizes 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` Prizes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Prizes.
|
|
*/
|
|
distinct?: PrizeScalarFieldEnum | PrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Prize findFirstOrThrow
|
|
*/
|
|
export type PrizeFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Prize to fetch.
|
|
*/
|
|
where?: PrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Prizes to fetch.
|
|
*/
|
|
orderBy?: PrizeOrderByWithRelationInput | PrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Prizes.
|
|
*/
|
|
cursor?: PrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Prizes 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` Prizes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Prizes.
|
|
*/
|
|
distinct?: PrizeScalarFieldEnum | PrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Prize findMany
|
|
*/
|
|
export type PrizeFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Prizes to fetch.
|
|
*/
|
|
where?: PrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Prizes to fetch.
|
|
*/
|
|
orderBy?: PrizeOrderByWithRelationInput | PrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Prizes.
|
|
*/
|
|
cursor?: PrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Prizes 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` Prizes.
|
|
*/
|
|
skip?: number
|
|
distinct?: PrizeScalarFieldEnum | PrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Prize create
|
|
*/
|
|
export type PrizeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Prize.
|
|
*/
|
|
data: XOR<PrizeCreateInput, PrizeUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Prize createMany
|
|
*/
|
|
export type PrizeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Prizes.
|
|
*/
|
|
data: PrizeCreateManyInput | PrizeCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Prize createManyAndReturn
|
|
*/
|
|
export type PrizeCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Prizes.
|
|
*/
|
|
data: PrizeCreateManyInput | PrizeCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Prize update
|
|
*/
|
|
export type PrizeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Prize.
|
|
*/
|
|
data: XOR<PrizeUpdateInput, PrizeUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Prize to update.
|
|
*/
|
|
where: PrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Prize updateMany
|
|
*/
|
|
export type PrizeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Prizes.
|
|
*/
|
|
data: XOR<PrizeUpdateManyMutationInput, PrizeUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Prizes to update
|
|
*/
|
|
where?: PrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* Prize upsert
|
|
*/
|
|
export type PrizeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Prize to update in case it exists.
|
|
*/
|
|
where: PrizeWhereUniqueInput
|
|
/**
|
|
* In case the Prize found by the `where` argument doesn't exist, create a new Prize with this data.
|
|
*/
|
|
create: XOR<PrizeCreateInput, PrizeUncheckedCreateInput>
|
|
/**
|
|
* In case the Prize was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<PrizeUpdateInput, PrizeUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Prize delete
|
|
*/
|
|
export type PrizeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Prize to delete.
|
|
*/
|
|
where: PrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Prize deleteMany
|
|
*/
|
|
export type PrizeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Prizes to delete
|
|
*/
|
|
where?: PrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* Prize.spins
|
|
*/
|
|
export type Prize$spinsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
where?: SpinWhereInput
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
cursor?: SpinWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: SpinScalarFieldEnum | SpinScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Prize.userPrizes
|
|
*/
|
|
export type Prize$userPrizesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
where?: UserPrizeWhereInput
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: UserPrizeScalarFieldEnum | UserPrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Prize without action
|
|
*/
|
|
export type PrizeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model UserCampaign
|
|
*/
|
|
|
|
export type AggregateUserCampaign = {
|
|
_count: UserCampaignCountAggregateOutputType | null
|
|
_avg: UserCampaignAvgAggregateOutputType | null
|
|
_sum: UserCampaignSumAggregateOutputType | null
|
|
_min: UserCampaignMinAggregateOutputType | null
|
|
_max: UserCampaignMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type UserCampaignAvgAggregateOutputType = {
|
|
totalChances: number | null
|
|
usedChances: number | null
|
|
}
|
|
|
|
export type UserCampaignSumAggregateOutputType = {
|
|
totalChances: number | null
|
|
usedChances: number | null
|
|
}
|
|
|
|
export type UserCampaignMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
totalChances: number | null
|
|
usedChances: number | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type UserCampaignMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
totalChances: number | null
|
|
usedChances: number | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type UserCampaignCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
campaignId: number
|
|
totalChances: number
|
|
usedChances: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type UserCampaignAvgAggregateInputType = {
|
|
totalChances?: true
|
|
usedChances?: true
|
|
}
|
|
|
|
export type UserCampaignSumAggregateInputType = {
|
|
totalChances?: true
|
|
usedChances?: true
|
|
}
|
|
|
|
export type UserCampaignMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
totalChances?: true
|
|
usedChances?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type UserCampaignMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
totalChances?: true
|
|
usedChances?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type UserCampaignCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
totalChances?: true
|
|
usedChances?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type UserCampaignAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which UserCampaign to aggregate.
|
|
*/
|
|
where?: UserCampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserCampaigns to fetch.
|
|
*/
|
|
orderBy?: UserCampaignOrderByWithRelationInput | UserCampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: UserCampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserCampaigns 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` UserCampaigns.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned UserCampaigns
|
|
**/
|
|
_count?: true | UserCampaignCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: UserCampaignAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: UserCampaignSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: UserCampaignMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: UserCampaignMaxAggregateInputType
|
|
}
|
|
|
|
export type GetUserCampaignAggregateType<T extends UserCampaignAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateUserCampaign]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateUserCampaign[P]>
|
|
: GetScalarType<T[P], AggregateUserCampaign[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type UserCampaignGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserCampaignWhereInput
|
|
orderBy?: UserCampaignOrderByWithAggregationInput | UserCampaignOrderByWithAggregationInput[]
|
|
by: UserCampaignScalarFieldEnum[] | UserCampaignScalarFieldEnum
|
|
having?: UserCampaignScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: UserCampaignCountAggregateInputType | true
|
|
_avg?: UserCampaignAvgAggregateInputType
|
|
_sum?: UserCampaignSumAggregateInputType
|
|
_min?: UserCampaignMinAggregateInputType
|
|
_max?: UserCampaignMaxAggregateInputType
|
|
}
|
|
|
|
export type UserCampaignGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
totalChances: number
|
|
usedChances: number
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: UserCampaignCountAggregateOutputType | null
|
|
_avg: UserCampaignAvgAggregateOutputType | null
|
|
_sum: UserCampaignSumAggregateOutputType | null
|
|
_min: UserCampaignMinAggregateOutputType | null
|
|
_max: UserCampaignMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetUserCampaignGroupByPayload<T extends UserCampaignGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<UserCampaignGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof UserCampaignGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], UserCampaignGroupByOutputType[P]>
|
|
: GetScalarType<T[P], UserCampaignGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type UserCampaignSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
totalChances?: boolean
|
|
usedChances?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["userCampaign"]>
|
|
|
|
export type UserCampaignSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
totalChances?: boolean
|
|
usedChances?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["userCampaign"]>
|
|
|
|
export type UserCampaignSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
totalChances?: boolean
|
|
usedChances?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type UserCampaignInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
}
|
|
export type UserCampaignIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $UserCampaignPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "UserCampaign"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
campaign: Prisma.$CampaignPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
totalChances: number
|
|
usedChances: number
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["userCampaign"]>
|
|
composites: {}
|
|
}
|
|
|
|
type UserCampaignGetPayload<S extends boolean | null | undefined | UserCampaignDefaultArgs> = $Result.GetResult<Prisma.$UserCampaignPayload, S>
|
|
|
|
type UserCampaignCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<UserCampaignFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: UserCampaignCountAggregateInputType | true
|
|
}
|
|
|
|
export interface UserCampaignDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['UserCampaign'], meta: { name: 'UserCampaign' } }
|
|
/**
|
|
* Find zero or one UserCampaign that matches the filter.
|
|
* @param {UserCampaignFindUniqueArgs} args - Arguments to find a UserCampaign
|
|
* @example
|
|
* // Get one UserCampaign
|
|
* const userCampaign = await prisma.userCampaign.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends UserCampaignFindUniqueArgs>(args: SelectSubset<T, UserCampaignFindUniqueArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one UserCampaign that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {UserCampaignFindUniqueOrThrowArgs} args - Arguments to find a UserCampaign
|
|
* @example
|
|
* // Get one UserCampaign
|
|
* const userCampaign = await prisma.userCampaign.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends UserCampaignFindUniqueOrThrowArgs>(args: SelectSubset<T, UserCampaignFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first UserCampaign 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 {UserCampaignFindFirstArgs} args - Arguments to find a UserCampaign
|
|
* @example
|
|
* // Get one UserCampaign
|
|
* const userCampaign = await prisma.userCampaign.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends UserCampaignFindFirstArgs>(args?: SelectSubset<T, UserCampaignFindFirstArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first UserCampaign 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 {UserCampaignFindFirstOrThrowArgs} args - Arguments to find a UserCampaign
|
|
* @example
|
|
* // Get one UserCampaign
|
|
* const userCampaign = await prisma.userCampaign.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends UserCampaignFindFirstOrThrowArgs>(args?: SelectSubset<T, UserCampaignFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more UserCampaigns 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 {UserCampaignFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all UserCampaigns
|
|
* const userCampaigns = await prisma.userCampaign.findMany()
|
|
*
|
|
* // Get first 10 UserCampaigns
|
|
* const userCampaigns = await prisma.userCampaign.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const userCampaignWithIdOnly = await prisma.userCampaign.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends UserCampaignFindManyArgs>(args?: SelectSubset<T, UserCampaignFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a UserCampaign.
|
|
* @param {UserCampaignCreateArgs} args - Arguments to create a UserCampaign.
|
|
* @example
|
|
* // Create one UserCampaign
|
|
* const UserCampaign = await prisma.userCampaign.create({
|
|
* data: {
|
|
* // ... data to create a UserCampaign
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends UserCampaignCreateArgs>(args: SelectSubset<T, UserCampaignCreateArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many UserCampaigns.
|
|
* @param {UserCampaignCreateManyArgs} args - Arguments to create many UserCampaigns.
|
|
* @example
|
|
* // Create many UserCampaigns
|
|
* const userCampaign = await prisma.userCampaign.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends UserCampaignCreateManyArgs>(args?: SelectSubset<T, UserCampaignCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many UserCampaigns and returns the data saved in the database.
|
|
* @param {UserCampaignCreateManyAndReturnArgs} args - Arguments to create many UserCampaigns.
|
|
* @example
|
|
* // Create many UserCampaigns
|
|
* const userCampaign = await prisma.userCampaign.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many UserCampaigns and only return the `id`
|
|
* const userCampaignWithIdOnly = await prisma.userCampaign.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 UserCampaignCreateManyAndReturnArgs>(args?: SelectSubset<T, UserCampaignCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a UserCampaign.
|
|
* @param {UserCampaignDeleteArgs} args - Arguments to delete one UserCampaign.
|
|
* @example
|
|
* // Delete one UserCampaign
|
|
* const UserCampaign = await prisma.userCampaign.delete({
|
|
* where: {
|
|
* // ... filter to delete one UserCampaign
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends UserCampaignDeleteArgs>(args: SelectSubset<T, UserCampaignDeleteArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one UserCampaign.
|
|
* @param {UserCampaignUpdateArgs} args - Arguments to update one UserCampaign.
|
|
* @example
|
|
* // Update one UserCampaign
|
|
* const userCampaign = await prisma.userCampaign.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends UserCampaignUpdateArgs>(args: SelectSubset<T, UserCampaignUpdateArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more UserCampaigns.
|
|
* @param {UserCampaignDeleteManyArgs} args - Arguments to filter UserCampaigns to delete.
|
|
* @example
|
|
* // Delete a few UserCampaigns
|
|
* const { count } = await prisma.userCampaign.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends UserCampaignDeleteManyArgs>(args?: SelectSubset<T, UserCampaignDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more UserCampaigns.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserCampaignUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many UserCampaigns
|
|
* const userCampaign = await prisma.userCampaign.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends UserCampaignUpdateManyArgs>(args: SelectSubset<T, UserCampaignUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one UserCampaign.
|
|
* @param {UserCampaignUpsertArgs} args - Arguments to update or create a UserCampaign.
|
|
* @example
|
|
* // Update or create a UserCampaign
|
|
* const userCampaign = await prisma.userCampaign.upsert({
|
|
* create: {
|
|
* // ... data to create a UserCampaign
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the UserCampaign we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends UserCampaignUpsertArgs>(args: SelectSubset<T, UserCampaignUpsertArgs<ExtArgs>>): Prisma__UserCampaignClient<$Result.GetResult<Prisma.$UserCampaignPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of UserCampaigns.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserCampaignCountArgs} args - Arguments to filter UserCampaigns to count.
|
|
* @example
|
|
* // Count the number of UserCampaigns
|
|
* const count = await prisma.userCampaign.count({
|
|
* where: {
|
|
* // ... the filter for the UserCampaigns we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends UserCampaignCountArgs>(
|
|
args?: Subset<T, UserCampaignCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], UserCampaignCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a UserCampaign.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserCampaignAggregateArgs} 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 UserCampaignAggregateArgs>(args: Subset<T, UserCampaignAggregateArgs>): Prisma.PrismaPromise<GetUserCampaignAggregateType<T>>
|
|
|
|
/**
|
|
* Group by UserCampaign.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserCampaignGroupByArgs} 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 UserCampaignGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: UserCampaignGroupByArgs['orderBy'] }
|
|
: { orderBy?: UserCampaignGroupByArgs['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, UserCampaignGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserCampaignGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the UserCampaign model
|
|
*/
|
|
readonly fields: UserCampaignFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for UserCampaign.
|
|
* 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__UserCampaignClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
campaign<T extends CampaignDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CampaignDefaultArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
/**
|
|
* 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 UserCampaign model
|
|
*/
|
|
interface UserCampaignFieldRefs {
|
|
readonly id: FieldRef<"UserCampaign", 'String'>
|
|
readonly userId: FieldRef<"UserCampaign", 'String'>
|
|
readonly campaignId: FieldRef<"UserCampaign", 'String'>
|
|
readonly totalChances: FieldRef<"UserCampaign", 'Int'>
|
|
readonly usedChances: FieldRef<"UserCampaign", 'Int'>
|
|
readonly createdAt: FieldRef<"UserCampaign", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"UserCampaign", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* UserCampaign findUnique
|
|
*/
|
|
export type UserCampaignFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserCampaign to fetch.
|
|
*/
|
|
where: UserCampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserCampaign findUniqueOrThrow
|
|
*/
|
|
export type UserCampaignFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserCampaign to fetch.
|
|
*/
|
|
where: UserCampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserCampaign findFirst
|
|
*/
|
|
export type UserCampaignFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserCampaign to fetch.
|
|
*/
|
|
where?: UserCampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserCampaigns to fetch.
|
|
*/
|
|
orderBy?: UserCampaignOrderByWithRelationInput | UserCampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for UserCampaigns.
|
|
*/
|
|
cursor?: UserCampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserCampaigns 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` UserCampaigns.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of UserCampaigns.
|
|
*/
|
|
distinct?: UserCampaignScalarFieldEnum | UserCampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* UserCampaign findFirstOrThrow
|
|
*/
|
|
export type UserCampaignFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserCampaign to fetch.
|
|
*/
|
|
where?: UserCampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserCampaigns to fetch.
|
|
*/
|
|
orderBy?: UserCampaignOrderByWithRelationInput | UserCampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for UserCampaigns.
|
|
*/
|
|
cursor?: UserCampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserCampaigns 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` UserCampaigns.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of UserCampaigns.
|
|
*/
|
|
distinct?: UserCampaignScalarFieldEnum | UserCampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* UserCampaign findMany
|
|
*/
|
|
export type UserCampaignFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserCampaigns to fetch.
|
|
*/
|
|
where?: UserCampaignWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserCampaigns to fetch.
|
|
*/
|
|
orderBy?: UserCampaignOrderByWithRelationInput | UserCampaignOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing UserCampaigns.
|
|
*/
|
|
cursor?: UserCampaignWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserCampaigns 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` UserCampaigns.
|
|
*/
|
|
skip?: number
|
|
distinct?: UserCampaignScalarFieldEnum | UserCampaignScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* UserCampaign create
|
|
*/
|
|
export type UserCampaignCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a UserCampaign.
|
|
*/
|
|
data: XOR<UserCampaignCreateInput, UserCampaignUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* UserCampaign createMany
|
|
*/
|
|
export type UserCampaignCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many UserCampaigns.
|
|
*/
|
|
data: UserCampaignCreateManyInput | UserCampaignCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* UserCampaign createManyAndReturn
|
|
*/
|
|
export type UserCampaignCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many UserCampaigns.
|
|
*/
|
|
data: UserCampaignCreateManyInput | UserCampaignCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* UserCampaign update
|
|
*/
|
|
export type UserCampaignUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a UserCampaign.
|
|
*/
|
|
data: XOR<UserCampaignUpdateInput, UserCampaignUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which UserCampaign to update.
|
|
*/
|
|
where: UserCampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserCampaign updateMany
|
|
*/
|
|
export type UserCampaignUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update UserCampaigns.
|
|
*/
|
|
data: XOR<UserCampaignUpdateManyMutationInput, UserCampaignUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which UserCampaigns to update
|
|
*/
|
|
where?: UserCampaignWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCampaign upsert
|
|
*/
|
|
export type UserCampaignUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the UserCampaign to update in case it exists.
|
|
*/
|
|
where: UserCampaignWhereUniqueInput
|
|
/**
|
|
* In case the UserCampaign found by the `where` argument doesn't exist, create a new UserCampaign with this data.
|
|
*/
|
|
create: XOR<UserCampaignCreateInput, UserCampaignUncheckedCreateInput>
|
|
/**
|
|
* In case the UserCampaign was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<UserCampaignUpdateInput, UserCampaignUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* UserCampaign delete
|
|
*/
|
|
export type UserCampaignDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which UserCampaign to delete.
|
|
*/
|
|
where: UserCampaignWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserCampaign deleteMany
|
|
*/
|
|
export type UserCampaignDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which UserCampaigns to delete
|
|
*/
|
|
where?: UserCampaignWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserCampaign without action
|
|
*/
|
|
export type UserCampaignDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserCampaign
|
|
*/
|
|
select?: UserCampaignSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserCampaignInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model ChanceTransaction
|
|
*/
|
|
|
|
export type AggregateChanceTransaction = {
|
|
_count: ChanceTransactionCountAggregateOutputType | null
|
|
_avg: ChanceTransactionAvgAggregateOutputType | null
|
|
_sum: ChanceTransactionSumAggregateOutputType | null
|
|
_min: ChanceTransactionMinAggregateOutputType | null
|
|
_max: ChanceTransactionMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type ChanceTransactionAvgAggregateOutputType = {
|
|
amount: number | null
|
|
}
|
|
|
|
export type ChanceTransactionSumAggregateOutputType = {
|
|
amount: number | null
|
|
}
|
|
|
|
export type ChanceTransactionMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
amount: number | null
|
|
type: $Enums.ChanceTxnType | null
|
|
referenceType: string | null
|
|
referenceId: string | null
|
|
description: string | null
|
|
createdById: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type ChanceTransactionMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
amount: number | null
|
|
type: $Enums.ChanceTxnType | null
|
|
referenceType: string | null
|
|
referenceId: string | null
|
|
description: string | null
|
|
createdById: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type ChanceTransactionCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
campaignId: number
|
|
amount: number
|
|
type: number
|
|
referenceType: number
|
|
referenceId: number
|
|
description: number
|
|
createdById: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type ChanceTransactionAvgAggregateInputType = {
|
|
amount?: true
|
|
}
|
|
|
|
export type ChanceTransactionSumAggregateInputType = {
|
|
amount?: true
|
|
}
|
|
|
|
export type ChanceTransactionMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
amount?: true
|
|
type?: true
|
|
referenceType?: true
|
|
referenceId?: true
|
|
description?: true
|
|
createdById?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type ChanceTransactionMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
amount?: true
|
|
type?: true
|
|
referenceType?: true
|
|
referenceId?: true
|
|
description?: true
|
|
createdById?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type ChanceTransactionCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
amount?: true
|
|
type?: true
|
|
referenceType?: true
|
|
referenceId?: true
|
|
description?: true
|
|
createdById?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type ChanceTransactionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which ChanceTransaction to aggregate.
|
|
*/
|
|
where?: ChanceTransactionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of ChanceTransactions to fetch.
|
|
*/
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` ChanceTransactions 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` ChanceTransactions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned ChanceTransactions
|
|
**/
|
|
_count?: true | ChanceTransactionCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: ChanceTransactionAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: ChanceTransactionSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: ChanceTransactionMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: ChanceTransactionMaxAggregateInputType
|
|
}
|
|
|
|
export type GetChanceTransactionAggregateType<T extends ChanceTransactionAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateChanceTransaction]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateChanceTransaction[P]>
|
|
: GetScalarType<T[P], AggregateChanceTransaction[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type ChanceTransactionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: ChanceTransactionWhereInput
|
|
orderBy?: ChanceTransactionOrderByWithAggregationInput | ChanceTransactionOrderByWithAggregationInput[]
|
|
by: ChanceTransactionScalarFieldEnum[] | ChanceTransactionScalarFieldEnum
|
|
having?: ChanceTransactionScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: ChanceTransactionCountAggregateInputType | true
|
|
_avg?: ChanceTransactionAvgAggregateInputType
|
|
_sum?: ChanceTransactionSumAggregateInputType
|
|
_min?: ChanceTransactionMinAggregateInputType
|
|
_max?: ChanceTransactionMaxAggregateInputType
|
|
}
|
|
|
|
export type ChanceTransactionGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType: string | null
|
|
referenceId: string | null
|
|
description: string | null
|
|
createdById: string | null
|
|
createdAt: Date
|
|
_count: ChanceTransactionCountAggregateOutputType | null
|
|
_avg: ChanceTransactionAvgAggregateOutputType | null
|
|
_sum: ChanceTransactionSumAggregateOutputType | null
|
|
_min: ChanceTransactionMinAggregateOutputType | null
|
|
_max: ChanceTransactionMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetChanceTransactionGroupByPayload<T extends ChanceTransactionGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<ChanceTransactionGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof ChanceTransactionGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], ChanceTransactionGroupByOutputType[P]>
|
|
: GetScalarType<T[P], ChanceTransactionGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type ChanceTransactionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
amount?: boolean
|
|
type?: boolean
|
|
referenceType?: boolean
|
|
referenceId?: boolean
|
|
description?: boolean
|
|
createdById?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
createdBy?: boolean | ChanceTransaction$createdByArgs<ExtArgs>
|
|
}, ExtArgs["result"]["chanceTransaction"]>
|
|
|
|
export type ChanceTransactionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
amount?: boolean
|
|
type?: boolean
|
|
referenceType?: boolean
|
|
referenceId?: boolean
|
|
description?: boolean
|
|
createdById?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
createdBy?: boolean | ChanceTransaction$createdByArgs<ExtArgs>
|
|
}, ExtArgs["result"]["chanceTransaction"]>
|
|
|
|
export type ChanceTransactionSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
amount?: boolean
|
|
type?: boolean
|
|
referenceType?: boolean
|
|
referenceId?: boolean
|
|
description?: boolean
|
|
createdById?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type ChanceTransactionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
createdBy?: boolean | ChanceTransaction$createdByArgs<ExtArgs>
|
|
}
|
|
export type ChanceTransactionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
createdBy?: boolean | ChanceTransaction$createdByArgs<ExtArgs>
|
|
}
|
|
|
|
export type $ChanceTransactionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "ChanceTransaction"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
campaign: Prisma.$CampaignPayload<ExtArgs>
|
|
createdBy: Prisma.$AdminPayload<ExtArgs> | null
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType: string | null
|
|
referenceId: string | null
|
|
description: string | null
|
|
createdById: string | null
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["chanceTransaction"]>
|
|
composites: {}
|
|
}
|
|
|
|
type ChanceTransactionGetPayload<S extends boolean | null | undefined | ChanceTransactionDefaultArgs> = $Result.GetResult<Prisma.$ChanceTransactionPayload, S>
|
|
|
|
type ChanceTransactionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<ChanceTransactionFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: ChanceTransactionCountAggregateInputType | true
|
|
}
|
|
|
|
export interface ChanceTransactionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ChanceTransaction'], meta: { name: 'ChanceTransaction' } }
|
|
/**
|
|
* Find zero or one ChanceTransaction that matches the filter.
|
|
* @param {ChanceTransactionFindUniqueArgs} args - Arguments to find a ChanceTransaction
|
|
* @example
|
|
* // Get one ChanceTransaction
|
|
* const chanceTransaction = await prisma.chanceTransaction.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends ChanceTransactionFindUniqueArgs>(args: SelectSubset<T, ChanceTransactionFindUniqueArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one ChanceTransaction that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {ChanceTransactionFindUniqueOrThrowArgs} args - Arguments to find a ChanceTransaction
|
|
* @example
|
|
* // Get one ChanceTransaction
|
|
* const chanceTransaction = await prisma.chanceTransaction.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends ChanceTransactionFindUniqueOrThrowArgs>(args: SelectSubset<T, ChanceTransactionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first ChanceTransaction 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 {ChanceTransactionFindFirstArgs} args - Arguments to find a ChanceTransaction
|
|
* @example
|
|
* // Get one ChanceTransaction
|
|
* const chanceTransaction = await prisma.chanceTransaction.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends ChanceTransactionFindFirstArgs>(args?: SelectSubset<T, ChanceTransactionFindFirstArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first ChanceTransaction 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 {ChanceTransactionFindFirstOrThrowArgs} args - Arguments to find a ChanceTransaction
|
|
* @example
|
|
* // Get one ChanceTransaction
|
|
* const chanceTransaction = await prisma.chanceTransaction.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends ChanceTransactionFindFirstOrThrowArgs>(args?: SelectSubset<T, ChanceTransactionFindFirstOrThrowArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more ChanceTransactions 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 {ChanceTransactionFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all ChanceTransactions
|
|
* const chanceTransactions = await prisma.chanceTransaction.findMany()
|
|
*
|
|
* // Get first 10 ChanceTransactions
|
|
* const chanceTransactions = await prisma.chanceTransaction.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const chanceTransactionWithIdOnly = await prisma.chanceTransaction.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends ChanceTransactionFindManyArgs>(args?: SelectSubset<T, ChanceTransactionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a ChanceTransaction.
|
|
* @param {ChanceTransactionCreateArgs} args - Arguments to create a ChanceTransaction.
|
|
* @example
|
|
* // Create one ChanceTransaction
|
|
* const ChanceTransaction = await prisma.chanceTransaction.create({
|
|
* data: {
|
|
* // ... data to create a ChanceTransaction
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends ChanceTransactionCreateArgs>(args: SelectSubset<T, ChanceTransactionCreateArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many ChanceTransactions.
|
|
* @param {ChanceTransactionCreateManyArgs} args - Arguments to create many ChanceTransactions.
|
|
* @example
|
|
* // Create many ChanceTransactions
|
|
* const chanceTransaction = await prisma.chanceTransaction.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends ChanceTransactionCreateManyArgs>(args?: SelectSubset<T, ChanceTransactionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many ChanceTransactions and returns the data saved in the database.
|
|
* @param {ChanceTransactionCreateManyAndReturnArgs} args - Arguments to create many ChanceTransactions.
|
|
* @example
|
|
* // Create many ChanceTransactions
|
|
* const chanceTransaction = await prisma.chanceTransaction.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many ChanceTransactions and only return the `id`
|
|
* const chanceTransactionWithIdOnly = await prisma.chanceTransaction.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 ChanceTransactionCreateManyAndReturnArgs>(args?: SelectSubset<T, ChanceTransactionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a ChanceTransaction.
|
|
* @param {ChanceTransactionDeleteArgs} args - Arguments to delete one ChanceTransaction.
|
|
* @example
|
|
* // Delete one ChanceTransaction
|
|
* const ChanceTransaction = await prisma.chanceTransaction.delete({
|
|
* where: {
|
|
* // ... filter to delete one ChanceTransaction
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends ChanceTransactionDeleteArgs>(args: SelectSubset<T, ChanceTransactionDeleteArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one ChanceTransaction.
|
|
* @param {ChanceTransactionUpdateArgs} args - Arguments to update one ChanceTransaction.
|
|
* @example
|
|
* // Update one ChanceTransaction
|
|
* const chanceTransaction = await prisma.chanceTransaction.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends ChanceTransactionUpdateArgs>(args: SelectSubset<T, ChanceTransactionUpdateArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more ChanceTransactions.
|
|
* @param {ChanceTransactionDeleteManyArgs} args - Arguments to filter ChanceTransactions to delete.
|
|
* @example
|
|
* // Delete a few ChanceTransactions
|
|
* const { count } = await prisma.chanceTransaction.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends ChanceTransactionDeleteManyArgs>(args?: SelectSubset<T, ChanceTransactionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more ChanceTransactions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ChanceTransactionUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many ChanceTransactions
|
|
* const chanceTransaction = await prisma.chanceTransaction.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends ChanceTransactionUpdateManyArgs>(args: SelectSubset<T, ChanceTransactionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one ChanceTransaction.
|
|
* @param {ChanceTransactionUpsertArgs} args - Arguments to update or create a ChanceTransaction.
|
|
* @example
|
|
* // Update or create a ChanceTransaction
|
|
* const chanceTransaction = await prisma.chanceTransaction.upsert({
|
|
* create: {
|
|
* // ... data to create a ChanceTransaction
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the ChanceTransaction we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends ChanceTransactionUpsertArgs>(args: SelectSubset<T, ChanceTransactionUpsertArgs<ExtArgs>>): Prisma__ChanceTransactionClient<$Result.GetResult<Prisma.$ChanceTransactionPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of ChanceTransactions.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ChanceTransactionCountArgs} args - Arguments to filter ChanceTransactions to count.
|
|
* @example
|
|
* // Count the number of ChanceTransactions
|
|
* const count = await prisma.chanceTransaction.count({
|
|
* where: {
|
|
* // ... the filter for the ChanceTransactions we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends ChanceTransactionCountArgs>(
|
|
args?: Subset<T, ChanceTransactionCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], ChanceTransactionCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a ChanceTransaction.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ChanceTransactionAggregateArgs} 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 ChanceTransactionAggregateArgs>(args: Subset<T, ChanceTransactionAggregateArgs>): Prisma.PrismaPromise<GetChanceTransactionAggregateType<T>>
|
|
|
|
/**
|
|
* Group by ChanceTransaction.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {ChanceTransactionGroupByArgs} 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 ChanceTransactionGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: ChanceTransactionGroupByArgs['orderBy'] }
|
|
: { orderBy?: ChanceTransactionGroupByArgs['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, ChanceTransactionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetChanceTransactionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the ChanceTransaction model
|
|
*/
|
|
readonly fields: ChanceTransactionFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for ChanceTransaction.
|
|
* 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__ChanceTransactionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
campaign<T extends CampaignDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CampaignDefaultArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
createdBy<T extends ChanceTransaction$createdByArgs<ExtArgs> = {}>(args?: Subset<T, ChanceTransaction$createdByArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
|
|
/**
|
|
* 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 ChanceTransaction model
|
|
*/
|
|
interface ChanceTransactionFieldRefs {
|
|
readonly id: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly userId: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly campaignId: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly amount: FieldRef<"ChanceTransaction", 'Int'>
|
|
readonly type: FieldRef<"ChanceTransaction", 'ChanceTxnType'>
|
|
readonly referenceType: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly referenceId: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly description: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly createdById: FieldRef<"ChanceTransaction", 'String'>
|
|
readonly createdAt: FieldRef<"ChanceTransaction", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* ChanceTransaction findUnique
|
|
*/
|
|
export type ChanceTransactionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which ChanceTransaction to fetch.
|
|
*/
|
|
where: ChanceTransactionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction findUniqueOrThrow
|
|
*/
|
|
export type ChanceTransactionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which ChanceTransaction to fetch.
|
|
*/
|
|
where: ChanceTransactionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction findFirst
|
|
*/
|
|
export type ChanceTransactionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which ChanceTransaction to fetch.
|
|
*/
|
|
where?: ChanceTransactionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of ChanceTransactions to fetch.
|
|
*/
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for ChanceTransactions.
|
|
*/
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` ChanceTransactions 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` ChanceTransactions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of ChanceTransactions.
|
|
*/
|
|
distinct?: ChanceTransactionScalarFieldEnum | ChanceTransactionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction findFirstOrThrow
|
|
*/
|
|
export type ChanceTransactionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which ChanceTransaction to fetch.
|
|
*/
|
|
where?: ChanceTransactionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of ChanceTransactions to fetch.
|
|
*/
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for ChanceTransactions.
|
|
*/
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` ChanceTransactions 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` ChanceTransactions.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of ChanceTransactions.
|
|
*/
|
|
distinct?: ChanceTransactionScalarFieldEnum | ChanceTransactionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction findMany
|
|
*/
|
|
export type ChanceTransactionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which ChanceTransactions to fetch.
|
|
*/
|
|
where?: ChanceTransactionWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of ChanceTransactions to fetch.
|
|
*/
|
|
orderBy?: ChanceTransactionOrderByWithRelationInput | ChanceTransactionOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing ChanceTransactions.
|
|
*/
|
|
cursor?: ChanceTransactionWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` ChanceTransactions 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` ChanceTransactions.
|
|
*/
|
|
skip?: number
|
|
distinct?: ChanceTransactionScalarFieldEnum | ChanceTransactionScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction create
|
|
*/
|
|
export type ChanceTransactionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a ChanceTransaction.
|
|
*/
|
|
data: XOR<ChanceTransactionCreateInput, ChanceTransactionUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction createMany
|
|
*/
|
|
export type ChanceTransactionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many ChanceTransactions.
|
|
*/
|
|
data: ChanceTransactionCreateManyInput | ChanceTransactionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction createManyAndReturn
|
|
*/
|
|
export type ChanceTransactionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many ChanceTransactions.
|
|
*/
|
|
data: ChanceTransactionCreateManyInput | ChanceTransactionCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction update
|
|
*/
|
|
export type ChanceTransactionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a ChanceTransaction.
|
|
*/
|
|
data: XOR<ChanceTransactionUpdateInput, ChanceTransactionUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which ChanceTransaction to update.
|
|
*/
|
|
where: ChanceTransactionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction updateMany
|
|
*/
|
|
export type ChanceTransactionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update ChanceTransactions.
|
|
*/
|
|
data: XOR<ChanceTransactionUpdateManyMutationInput, ChanceTransactionUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which ChanceTransactions to update
|
|
*/
|
|
where?: ChanceTransactionWhereInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction upsert
|
|
*/
|
|
export type ChanceTransactionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the ChanceTransaction to update in case it exists.
|
|
*/
|
|
where: ChanceTransactionWhereUniqueInput
|
|
/**
|
|
* In case the ChanceTransaction found by the `where` argument doesn't exist, create a new ChanceTransaction with this data.
|
|
*/
|
|
create: XOR<ChanceTransactionCreateInput, ChanceTransactionUncheckedCreateInput>
|
|
/**
|
|
* In case the ChanceTransaction was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<ChanceTransactionUpdateInput, ChanceTransactionUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction delete
|
|
*/
|
|
export type ChanceTransactionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which ChanceTransaction to delete.
|
|
*/
|
|
where: ChanceTransactionWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction deleteMany
|
|
*/
|
|
export type ChanceTransactionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which ChanceTransactions to delete
|
|
*/
|
|
where?: ChanceTransactionWhereInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction.createdBy
|
|
*/
|
|
export type ChanceTransaction$createdByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Admin
|
|
*/
|
|
select?: AdminSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminInclude<ExtArgs> | null
|
|
where?: AdminWhereInput
|
|
}
|
|
|
|
/**
|
|
* ChanceTransaction without action
|
|
*/
|
|
export type ChanceTransactionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the ChanceTransaction
|
|
*/
|
|
select?: ChanceTransactionSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: ChanceTransactionInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Spin
|
|
*/
|
|
|
|
export type AggregateSpin = {
|
|
_count: SpinCountAggregateOutputType | null
|
|
_min: SpinMinAggregateOutputType | null
|
|
_max: SpinMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type SpinMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
prizeId: string | null
|
|
status: $Enums.SpinStatus | null
|
|
idempotencyKey: string | null
|
|
ip: string | null
|
|
userAgent: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type SpinMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
prizeId: string | null
|
|
status: $Enums.SpinStatus | null
|
|
idempotencyKey: string | null
|
|
ip: string | null
|
|
userAgent: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type SpinCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
campaignId: number
|
|
prizeId: number
|
|
status: number
|
|
idempotencyKey: number
|
|
ip: number
|
|
userAgent: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type SpinMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
prizeId?: true
|
|
status?: true
|
|
idempotencyKey?: true
|
|
ip?: true
|
|
userAgent?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type SpinMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
prizeId?: true
|
|
status?: true
|
|
idempotencyKey?: true
|
|
ip?: true
|
|
userAgent?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type SpinCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
prizeId?: true
|
|
status?: true
|
|
idempotencyKey?: true
|
|
ip?: true
|
|
userAgent?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type SpinAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Spin to aggregate.
|
|
*/
|
|
where?: SpinWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Spins to fetch.
|
|
*/
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: SpinWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Spins 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` Spins.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Spins
|
|
**/
|
|
_count?: true | SpinCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: SpinMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: SpinMaxAggregateInputType
|
|
}
|
|
|
|
export type GetSpinAggregateType<T extends SpinAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateSpin]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateSpin[P]>
|
|
: GetScalarType<T[P], AggregateSpin[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type SpinGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SpinWhereInput
|
|
orderBy?: SpinOrderByWithAggregationInput | SpinOrderByWithAggregationInput[]
|
|
by: SpinScalarFieldEnum[] | SpinScalarFieldEnum
|
|
having?: SpinScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: SpinCountAggregateInputType | true
|
|
_min?: SpinMinAggregateInputType
|
|
_max?: SpinMaxAggregateInputType
|
|
}
|
|
|
|
export type SpinGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string | null
|
|
status: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip: string | null
|
|
userAgent: string | null
|
|
createdAt: Date
|
|
_count: SpinCountAggregateOutputType | null
|
|
_min: SpinMinAggregateOutputType | null
|
|
_max: SpinMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetSpinGroupByPayload<T extends SpinGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<SpinGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof SpinGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], SpinGroupByOutputType[P]>
|
|
: GetScalarType<T[P], SpinGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type SpinSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
prizeId?: boolean
|
|
status?: boolean
|
|
idempotencyKey?: boolean
|
|
ip?: boolean
|
|
userAgent?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | Spin$prizeArgs<ExtArgs>
|
|
userPrize?: boolean | Spin$userPrizeArgs<ExtArgs>
|
|
}, ExtArgs["result"]["spin"]>
|
|
|
|
export type SpinSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
prizeId?: boolean
|
|
status?: boolean
|
|
idempotencyKey?: boolean
|
|
ip?: boolean
|
|
userAgent?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | Spin$prizeArgs<ExtArgs>
|
|
}, ExtArgs["result"]["spin"]>
|
|
|
|
export type SpinSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
prizeId?: boolean
|
|
status?: boolean
|
|
idempotencyKey?: boolean
|
|
ip?: boolean
|
|
userAgent?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type SpinInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | Spin$prizeArgs<ExtArgs>
|
|
userPrize?: boolean | Spin$userPrizeArgs<ExtArgs>
|
|
}
|
|
export type SpinIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | Spin$prizeArgs<ExtArgs>
|
|
}
|
|
|
|
export type $SpinPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Spin"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
campaign: Prisma.$CampaignPayload<ExtArgs>
|
|
prize: Prisma.$PrizePayload<ExtArgs> | null
|
|
userPrize: Prisma.$UserPrizePayload<ExtArgs> | null
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string | null
|
|
status: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip: string | null
|
|
userAgent: string | null
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["spin"]>
|
|
composites: {}
|
|
}
|
|
|
|
type SpinGetPayload<S extends boolean | null | undefined | SpinDefaultArgs> = $Result.GetResult<Prisma.$SpinPayload, S>
|
|
|
|
type SpinCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<SpinFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: SpinCountAggregateInputType | true
|
|
}
|
|
|
|
export interface SpinDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Spin'], meta: { name: 'Spin' } }
|
|
/**
|
|
* Find zero or one Spin that matches the filter.
|
|
* @param {SpinFindUniqueArgs} args - Arguments to find a Spin
|
|
* @example
|
|
* // Get one Spin
|
|
* const spin = await prisma.spin.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends SpinFindUniqueArgs>(args: SelectSubset<T, SpinFindUniqueArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one Spin that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {SpinFindUniqueOrThrowArgs} args - Arguments to find a Spin
|
|
* @example
|
|
* // Get one Spin
|
|
* const spin = await prisma.spin.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends SpinFindUniqueOrThrowArgs>(args: SelectSubset<T, SpinFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Spin 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 {SpinFindFirstArgs} args - Arguments to find a Spin
|
|
* @example
|
|
* // Get one Spin
|
|
* const spin = await prisma.spin.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends SpinFindFirstArgs>(args?: SelectSubset<T, SpinFindFirstArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first Spin 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 {SpinFindFirstOrThrowArgs} args - Arguments to find a Spin
|
|
* @example
|
|
* // Get one Spin
|
|
* const spin = await prisma.spin.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends SpinFindFirstOrThrowArgs>(args?: SelectSubset<T, SpinFindFirstOrThrowArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more Spins 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 {SpinFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Spins
|
|
* const spins = await prisma.spin.findMany()
|
|
*
|
|
* // Get first 10 Spins
|
|
* const spins = await prisma.spin.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const spinWithIdOnly = await prisma.spin.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends SpinFindManyArgs>(args?: SelectSubset<T, SpinFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a Spin.
|
|
* @param {SpinCreateArgs} args - Arguments to create a Spin.
|
|
* @example
|
|
* // Create one Spin
|
|
* const Spin = await prisma.spin.create({
|
|
* data: {
|
|
* // ... data to create a Spin
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends SpinCreateArgs>(args: SelectSubset<T, SpinCreateArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many Spins.
|
|
* @param {SpinCreateManyArgs} args - Arguments to create many Spins.
|
|
* @example
|
|
* // Create many Spins
|
|
* const spin = await prisma.spin.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends SpinCreateManyArgs>(args?: SelectSubset<T, SpinCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Spins and returns the data saved in the database.
|
|
* @param {SpinCreateManyAndReturnArgs} args - Arguments to create many Spins.
|
|
* @example
|
|
* // Create many Spins
|
|
* const spin = await prisma.spin.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Spins and only return the `id`
|
|
* const spinWithIdOnly = await prisma.spin.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 SpinCreateManyAndReturnArgs>(args?: SelectSubset<T, SpinCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a Spin.
|
|
* @param {SpinDeleteArgs} args - Arguments to delete one Spin.
|
|
* @example
|
|
* // Delete one Spin
|
|
* const Spin = await prisma.spin.delete({
|
|
* where: {
|
|
* // ... filter to delete one Spin
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends SpinDeleteArgs>(args: SelectSubset<T, SpinDeleteArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one Spin.
|
|
* @param {SpinUpdateArgs} args - Arguments to update one Spin.
|
|
* @example
|
|
* // Update one Spin
|
|
* const spin = await prisma.spin.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends SpinUpdateArgs>(args: SelectSubset<T, SpinUpdateArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more Spins.
|
|
* @param {SpinDeleteManyArgs} args - Arguments to filter Spins to delete.
|
|
* @example
|
|
* // Delete a few Spins
|
|
* const { count } = await prisma.spin.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends SpinDeleteManyArgs>(args?: SelectSubset<T, SpinDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Spins.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SpinUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Spins
|
|
* const spin = await prisma.spin.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends SpinUpdateManyArgs>(args: SelectSubset<T, SpinUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one Spin.
|
|
* @param {SpinUpsertArgs} args - Arguments to update or create a Spin.
|
|
* @example
|
|
* // Update or create a Spin
|
|
* const spin = await prisma.spin.upsert({
|
|
* create: {
|
|
* // ... data to create a Spin
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Spin we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends SpinUpsertArgs>(args: SelectSubset<T, SpinUpsertArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of Spins.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SpinCountArgs} args - Arguments to filter Spins to count.
|
|
* @example
|
|
* // Count the number of Spins
|
|
* const count = await prisma.spin.count({
|
|
* where: {
|
|
* // ... the filter for the Spins we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends SpinCountArgs>(
|
|
args?: Subset<T, SpinCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], SpinCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Spin.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SpinAggregateArgs} 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 SpinAggregateArgs>(args: Subset<T, SpinAggregateArgs>): Prisma.PrismaPromise<GetSpinAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Spin.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SpinGroupByArgs} 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 SpinGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: SpinGroupByArgs['orderBy'] }
|
|
: { orderBy?: SpinGroupByArgs['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, SpinGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSpinGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Spin model
|
|
*/
|
|
readonly fields: SpinFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Spin.
|
|
* 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__SpinClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
campaign<T extends CampaignDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CampaignDefaultArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
prize<T extends Spin$prizeArgs<ExtArgs> = {}>(args?: Subset<T, Spin$prizeArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
|
|
userPrize<T extends Spin$userPrizeArgs<ExtArgs> = {}>(args?: Subset<T, Spin$userPrizeArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
|
|
/**
|
|
* 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 Spin model
|
|
*/
|
|
interface SpinFieldRefs {
|
|
readonly id: FieldRef<"Spin", 'String'>
|
|
readonly userId: FieldRef<"Spin", 'String'>
|
|
readonly campaignId: FieldRef<"Spin", 'String'>
|
|
readonly prizeId: FieldRef<"Spin", 'String'>
|
|
readonly status: FieldRef<"Spin", 'SpinStatus'>
|
|
readonly idempotencyKey: FieldRef<"Spin", 'String'>
|
|
readonly ip: FieldRef<"Spin", 'String'>
|
|
readonly userAgent: FieldRef<"Spin", 'String'>
|
|
readonly createdAt: FieldRef<"Spin", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Spin findUnique
|
|
*/
|
|
export type SpinFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Spin to fetch.
|
|
*/
|
|
where: SpinWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Spin findUniqueOrThrow
|
|
*/
|
|
export type SpinFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Spin to fetch.
|
|
*/
|
|
where: SpinWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Spin findFirst
|
|
*/
|
|
export type SpinFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Spin to fetch.
|
|
*/
|
|
where?: SpinWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Spins to fetch.
|
|
*/
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Spins.
|
|
*/
|
|
cursor?: SpinWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Spins 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` Spins.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Spins.
|
|
*/
|
|
distinct?: SpinScalarFieldEnum | SpinScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Spin findFirstOrThrow
|
|
*/
|
|
export type SpinFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Spin to fetch.
|
|
*/
|
|
where?: SpinWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Spins to fetch.
|
|
*/
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Spins.
|
|
*/
|
|
cursor?: SpinWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Spins 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` Spins.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Spins.
|
|
*/
|
|
distinct?: SpinScalarFieldEnum | SpinScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Spin findMany
|
|
*/
|
|
export type SpinFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Spins to fetch.
|
|
*/
|
|
where?: SpinWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Spins to fetch.
|
|
*/
|
|
orderBy?: SpinOrderByWithRelationInput | SpinOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Spins.
|
|
*/
|
|
cursor?: SpinWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Spins 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` Spins.
|
|
*/
|
|
skip?: number
|
|
distinct?: SpinScalarFieldEnum | SpinScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Spin create
|
|
*/
|
|
export type SpinCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Spin.
|
|
*/
|
|
data: XOR<SpinCreateInput, SpinUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Spin createMany
|
|
*/
|
|
export type SpinCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Spins.
|
|
*/
|
|
data: SpinCreateManyInput | SpinCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Spin createManyAndReturn
|
|
*/
|
|
export type SpinCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Spins.
|
|
*/
|
|
data: SpinCreateManyInput | SpinCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Spin update
|
|
*/
|
|
export type SpinUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Spin.
|
|
*/
|
|
data: XOR<SpinUpdateInput, SpinUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Spin to update.
|
|
*/
|
|
where: SpinWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Spin updateMany
|
|
*/
|
|
export type SpinUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Spins.
|
|
*/
|
|
data: XOR<SpinUpdateManyMutationInput, SpinUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Spins to update
|
|
*/
|
|
where?: SpinWhereInput
|
|
}
|
|
|
|
/**
|
|
* Spin upsert
|
|
*/
|
|
export type SpinUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Spin to update in case it exists.
|
|
*/
|
|
where: SpinWhereUniqueInput
|
|
/**
|
|
* In case the Spin found by the `where` argument doesn't exist, create a new Spin with this data.
|
|
*/
|
|
create: XOR<SpinCreateInput, SpinUncheckedCreateInput>
|
|
/**
|
|
* In case the Spin was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<SpinUpdateInput, SpinUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Spin delete
|
|
*/
|
|
export type SpinDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Spin to delete.
|
|
*/
|
|
where: SpinWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Spin deleteMany
|
|
*/
|
|
export type SpinDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Spins to delete
|
|
*/
|
|
where?: SpinWhereInput
|
|
}
|
|
|
|
/**
|
|
* Spin.prize
|
|
*/
|
|
export type Spin$prizeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Prize
|
|
*/
|
|
select?: PrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PrizeInclude<ExtArgs> | null
|
|
where?: PrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* Spin.userPrize
|
|
*/
|
|
export type Spin$userPrizeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* Spin without action
|
|
*/
|
|
export type SpinDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Spin
|
|
*/
|
|
select?: SpinSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SpinInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model UserPrize
|
|
*/
|
|
|
|
export type AggregateUserPrize = {
|
|
_count: UserPrizeCountAggregateOutputType | null
|
|
_min: UserPrizeMinAggregateOutputType | null
|
|
_max: UserPrizeMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type UserPrizeMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
prizeId: string | null
|
|
spinId: string | null
|
|
code: string | null
|
|
status: $Enums.UserPrizeStatus | null
|
|
wonAt: Date | null
|
|
redeemedAt: Date | null
|
|
}
|
|
|
|
export type UserPrizeMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
campaignId: string | null
|
|
prizeId: string | null
|
|
spinId: string | null
|
|
code: string | null
|
|
status: $Enums.UserPrizeStatus | null
|
|
wonAt: Date | null
|
|
redeemedAt: Date | null
|
|
}
|
|
|
|
export type UserPrizeCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
campaignId: number
|
|
prizeId: number
|
|
spinId: number
|
|
code: number
|
|
status: number
|
|
wonAt: number
|
|
redeemedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type UserPrizeMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
prizeId?: true
|
|
spinId?: true
|
|
code?: true
|
|
status?: true
|
|
wonAt?: true
|
|
redeemedAt?: true
|
|
}
|
|
|
|
export type UserPrizeMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
prizeId?: true
|
|
spinId?: true
|
|
code?: true
|
|
status?: true
|
|
wonAt?: true
|
|
redeemedAt?: true
|
|
}
|
|
|
|
export type UserPrizeCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
campaignId?: true
|
|
prizeId?: true
|
|
spinId?: true
|
|
code?: true
|
|
status?: true
|
|
wonAt?: true
|
|
redeemedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type UserPrizeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which UserPrize to aggregate.
|
|
*/
|
|
where?: UserPrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserPrizes to fetch.
|
|
*/
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserPrizes 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` UserPrizes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned UserPrizes
|
|
**/
|
|
_count?: true | UserPrizeCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: UserPrizeMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: UserPrizeMaxAggregateInputType
|
|
}
|
|
|
|
export type GetUserPrizeAggregateType<T extends UserPrizeAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateUserPrize]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateUserPrize[P]>
|
|
: GetScalarType<T[P], AggregateUserPrize[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type UserPrizeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UserPrizeWhereInput
|
|
orderBy?: UserPrizeOrderByWithAggregationInput | UserPrizeOrderByWithAggregationInput[]
|
|
by: UserPrizeScalarFieldEnum[] | UserPrizeScalarFieldEnum
|
|
having?: UserPrizeScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: UserPrizeCountAggregateInputType | true
|
|
_min?: UserPrizeMinAggregateInputType
|
|
_max?: UserPrizeMaxAggregateInputType
|
|
}
|
|
|
|
export type UserPrizeGroupByOutputType = {
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code: string | null
|
|
status: $Enums.UserPrizeStatus
|
|
wonAt: Date
|
|
redeemedAt: Date | null
|
|
_count: UserPrizeCountAggregateOutputType | null
|
|
_min: UserPrizeMinAggregateOutputType | null
|
|
_max: UserPrizeMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetUserPrizeGroupByPayload<T extends UserPrizeGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<UserPrizeGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof UserPrizeGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], UserPrizeGroupByOutputType[P]>
|
|
: GetScalarType<T[P], UserPrizeGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type UserPrizeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
prizeId?: boolean
|
|
spinId?: boolean
|
|
code?: boolean
|
|
status?: boolean
|
|
wonAt?: boolean
|
|
redeemedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | PrizeDefaultArgs<ExtArgs>
|
|
spin?: boolean | SpinDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["userPrize"]>
|
|
|
|
export type UserPrizeSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
prizeId?: boolean
|
|
spinId?: boolean
|
|
code?: boolean
|
|
status?: boolean
|
|
wonAt?: boolean
|
|
redeemedAt?: boolean
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | PrizeDefaultArgs<ExtArgs>
|
|
spin?: boolean | SpinDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["userPrize"]>
|
|
|
|
export type UserPrizeSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
campaignId?: boolean
|
|
prizeId?: boolean
|
|
spinId?: boolean
|
|
code?: boolean
|
|
status?: boolean
|
|
wonAt?: boolean
|
|
redeemedAt?: boolean
|
|
}
|
|
|
|
export type UserPrizeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | PrizeDefaultArgs<ExtArgs>
|
|
spin?: boolean | SpinDefaultArgs<ExtArgs>
|
|
}
|
|
export type UserPrizeIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | UserDefaultArgs<ExtArgs>
|
|
campaign?: boolean | CampaignDefaultArgs<ExtArgs>
|
|
prize?: boolean | PrizeDefaultArgs<ExtArgs>
|
|
spin?: boolean | SpinDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $UserPrizePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "UserPrize"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs>
|
|
campaign: Prisma.$CampaignPayload<ExtArgs>
|
|
prize: Prisma.$PrizePayload<ExtArgs>
|
|
spin: Prisma.$SpinPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code: string | null
|
|
status: $Enums.UserPrizeStatus
|
|
wonAt: Date
|
|
redeemedAt: Date | null
|
|
}, ExtArgs["result"]["userPrize"]>
|
|
composites: {}
|
|
}
|
|
|
|
type UserPrizeGetPayload<S extends boolean | null | undefined | UserPrizeDefaultArgs> = $Result.GetResult<Prisma.$UserPrizePayload, S>
|
|
|
|
type UserPrizeCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<UserPrizeFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: UserPrizeCountAggregateInputType | true
|
|
}
|
|
|
|
export interface UserPrizeDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['UserPrize'], meta: { name: 'UserPrize' } }
|
|
/**
|
|
* Find zero or one UserPrize that matches the filter.
|
|
* @param {UserPrizeFindUniqueArgs} args - Arguments to find a UserPrize
|
|
* @example
|
|
* // Get one UserPrize
|
|
* const userPrize = await prisma.userPrize.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends UserPrizeFindUniqueArgs>(args: SelectSubset<T, UserPrizeFindUniqueArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one UserPrize that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {UserPrizeFindUniqueOrThrowArgs} args - Arguments to find a UserPrize
|
|
* @example
|
|
* // Get one UserPrize
|
|
* const userPrize = await prisma.userPrize.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends UserPrizeFindUniqueOrThrowArgs>(args: SelectSubset<T, UserPrizeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first UserPrize 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 {UserPrizeFindFirstArgs} args - Arguments to find a UserPrize
|
|
* @example
|
|
* // Get one UserPrize
|
|
* const userPrize = await prisma.userPrize.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends UserPrizeFindFirstArgs>(args?: SelectSubset<T, UserPrizeFindFirstArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first UserPrize 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 {UserPrizeFindFirstOrThrowArgs} args - Arguments to find a UserPrize
|
|
* @example
|
|
* // Get one UserPrize
|
|
* const userPrize = await prisma.userPrize.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends UserPrizeFindFirstOrThrowArgs>(args?: SelectSubset<T, UserPrizeFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more UserPrizes 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 {UserPrizeFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all UserPrizes
|
|
* const userPrizes = await prisma.userPrize.findMany()
|
|
*
|
|
* // Get first 10 UserPrizes
|
|
* const userPrizes = await prisma.userPrize.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const userPrizeWithIdOnly = await prisma.userPrize.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends UserPrizeFindManyArgs>(args?: SelectSubset<T, UserPrizeFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a UserPrize.
|
|
* @param {UserPrizeCreateArgs} args - Arguments to create a UserPrize.
|
|
* @example
|
|
* // Create one UserPrize
|
|
* const UserPrize = await prisma.userPrize.create({
|
|
* data: {
|
|
* // ... data to create a UserPrize
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends UserPrizeCreateArgs>(args: SelectSubset<T, UserPrizeCreateArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many UserPrizes.
|
|
* @param {UserPrizeCreateManyArgs} args - Arguments to create many UserPrizes.
|
|
* @example
|
|
* // Create many UserPrizes
|
|
* const userPrize = await prisma.userPrize.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends UserPrizeCreateManyArgs>(args?: SelectSubset<T, UserPrizeCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many UserPrizes and returns the data saved in the database.
|
|
* @param {UserPrizeCreateManyAndReturnArgs} args - Arguments to create many UserPrizes.
|
|
* @example
|
|
* // Create many UserPrizes
|
|
* const userPrize = await prisma.userPrize.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many UserPrizes and only return the `id`
|
|
* const userPrizeWithIdOnly = await prisma.userPrize.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 UserPrizeCreateManyAndReturnArgs>(args?: SelectSubset<T, UserPrizeCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a UserPrize.
|
|
* @param {UserPrizeDeleteArgs} args - Arguments to delete one UserPrize.
|
|
* @example
|
|
* // Delete one UserPrize
|
|
* const UserPrize = await prisma.userPrize.delete({
|
|
* where: {
|
|
* // ... filter to delete one UserPrize
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends UserPrizeDeleteArgs>(args: SelectSubset<T, UserPrizeDeleteArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one UserPrize.
|
|
* @param {UserPrizeUpdateArgs} args - Arguments to update one UserPrize.
|
|
* @example
|
|
* // Update one UserPrize
|
|
* const userPrize = await prisma.userPrize.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends UserPrizeUpdateArgs>(args: SelectSubset<T, UserPrizeUpdateArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more UserPrizes.
|
|
* @param {UserPrizeDeleteManyArgs} args - Arguments to filter UserPrizes to delete.
|
|
* @example
|
|
* // Delete a few UserPrizes
|
|
* const { count } = await prisma.userPrize.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends UserPrizeDeleteManyArgs>(args?: SelectSubset<T, UserPrizeDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more UserPrizes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserPrizeUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many UserPrizes
|
|
* const userPrize = await prisma.userPrize.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends UserPrizeUpdateManyArgs>(args: SelectSubset<T, UserPrizeUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one UserPrize.
|
|
* @param {UserPrizeUpsertArgs} args - Arguments to update or create a UserPrize.
|
|
* @example
|
|
* // Update or create a UserPrize
|
|
* const userPrize = await prisma.userPrize.upsert({
|
|
* create: {
|
|
* // ... data to create a UserPrize
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the UserPrize we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends UserPrizeUpsertArgs>(args: SelectSubset<T, UserPrizeUpsertArgs<ExtArgs>>): Prisma__UserPrizeClient<$Result.GetResult<Prisma.$UserPrizePayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of UserPrizes.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserPrizeCountArgs} args - Arguments to filter UserPrizes to count.
|
|
* @example
|
|
* // Count the number of UserPrizes
|
|
* const count = await prisma.userPrize.count({
|
|
* where: {
|
|
* // ... the filter for the UserPrizes we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends UserPrizeCountArgs>(
|
|
args?: Subset<T, UserPrizeCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], UserPrizeCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a UserPrize.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserPrizeAggregateArgs} 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 UserPrizeAggregateArgs>(args: Subset<T, UserPrizeAggregateArgs>): Prisma.PrismaPromise<GetUserPrizeAggregateType<T>>
|
|
|
|
/**
|
|
* Group by UserPrize.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UserPrizeGroupByArgs} 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 UserPrizeGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: UserPrizeGroupByArgs['orderBy'] }
|
|
: { orderBy?: UserPrizeGroupByArgs['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, UserPrizeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserPrizeGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the UserPrize model
|
|
*/
|
|
readonly fields: UserPrizeFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for UserPrize.
|
|
* 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__UserPrizeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
campaign<T extends CampaignDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CampaignDefaultArgs<ExtArgs>>): Prisma__CampaignClient<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
prize<T extends PrizeDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PrizeDefaultArgs<ExtArgs>>): Prisma__PrizeClient<$Result.GetResult<Prisma.$PrizePayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
spin<T extends SpinDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SpinDefaultArgs<ExtArgs>>): Prisma__SpinClient<$Result.GetResult<Prisma.$SpinPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
/**
|
|
* 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 UserPrize model
|
|
*/
|
|
interface UserPrizeFieldRefs {
|
|
readonly id: FieldRef<"UserPrize", 'String'>
|
|
readonly userId: FieldRef<"UserPrize", 'String'>
|
|
readonly campaignId: FieldRef<"UserPrize", 'String'>
|
|
readonly prizeId: FieldRef<"UserPrize", 'String'>
|
|
readonly spinId: FieldRef<"UserPrize", 'String'>
|
|
readonly code: FieldRef<"UserPrize", 'String'>
|
|
readonly status: FieldRef<"UserPrize", 'UserPrizeStatus'>
|
|
readonly wonAt: FieldRef<"UserPrize", 'DateTime'>
|
|
readonly redeemedAt: FieldRef<"UserPrize", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* UserPrize findUnique
|
|
*/
|
|
export type UserPrizeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserPrize to fetch.
|
|
*/
|
|
where: UserPrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserPrize findUniqueOrThrow
|
|
*/
|
|
export type UserPrizeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserPrize to fetch.
|
|
*/
|
|
where: UserPrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserPrize findFirst
|
|
*/
|
|
export type UserPrizeFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserPrize to fetch.
|
|
*/
|
|
where?: UserPrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserPrizes to fetch.
|
|
*/
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for UserPrizes.
|
|
*/
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserPrizes 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` UserPrizes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of UserPrizes.
|
|
*/
|
|
distinct?: UserPrizeScalarFieldEnum | UserPrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* UserPrize findFirstOrThrow
|
|
*/
|
|
export type UserPrizeFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserPrize to fetch.
|
|
*/
|
|
where?: UserPrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserPrizes to fetch.
|
|
*/
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for UserPrizes.
|
|
*/
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserPrizes 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` UserPrizes.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of UserPrizes.
|
|
*/
|
|
distinct?: UserPrizeScalarFieldEnum | UserPrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* UserPrize findMany
|
|
*/
|
|
export type UserPrizeFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which UserPrizes to fetch.
|
|
*/
|
|
where?: UserPrizeWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of UserPrizes to fetch.
|
|
*/
|
|
orderBy?: UserPrizeOrderByWithRelationInput | UserPrizeOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing UserPrizes.
|
|
*/
|
|
cursor?: UserPrizeWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` UserPrizes 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` UserPrizes.
|
|
*/
|
|
skip?: number
|
|
distinct?: UserPrizeScalarFieldEnum | UserPrizeScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* UserPrize create
|
|
*/
|
|
export type UserPrizeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a UserPrize.
|
|
*/
|
|
data: XOR<UserPrizeCreateInput, UserPrizeUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* UserPrize createMany
|
|
*/
|
|
export type UserPrizeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many UserPrizes.
|
|
*/
|
|
data: UserPrizeCreateManyInput | UserPrizeCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* UserPrize createManyAndReturn
|
|
*/
|
|
export type UserPrizeCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many UserPrizes.
|
|
*/
|
|
data: UserPrizeCreateManyInput | UserPrizeCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* UserPrize update
|
|
*/
|
|
export type UserPrizeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a UserPrize.
|
|
*/
|
|
data: XOR<UserPrizeUpdateInput, UserPrizeUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which UserPrize to update.
|
|
*/
|
|
where: UserPrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserPrize updateMany
|
|
*/
|
|
export type UserPrizeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update UserPrizes.
|
|
*/
|
|
data: XOR<UserPrizeUpdateManyMutationInput, UserPrizeUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which UserPrizes to update
|
|
*/
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserPrize upsert
|
|
*/
|
|
export type UserPrizeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the UserPrize to update in case it exists.
|
|
*/
|
|
where: UserPrizeWhereUniqueInput
|
|
/**
|
|
* In case the UserPrize found by the `where` argument doesn't exist, create a new UserPrize with this data.
|
|
*/
|
|
create: XOR<UserPrizeCreateInput, UserPrizeUncheckedCreateInput>
|
|
/**
|
|
* In case the UserPrize was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<UserPrizeUpdateInput, UserPrizeUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* UserPrize delete
|
|
*/
|
|
export type UserPrizeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which UserPrize to delete.
|
|
*/
|
|
where: UserPrizeWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* UserPrize deleteMany
|
|
*/
|
|
export type UserPrizeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which UserPrizes to delete
|
|
*/
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
/**
|
|
* UserPrize without action
|
|
*/
|
|
export type UserPrizeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UserPrize
|
|
*/
|
|
select?: UserPrizeSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserPrizeInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model SmsLog
|
|
*/
|
|
|
|
export type AggregateSmsLog = {
|
|
_count: SmsLogCountAggregateOutputType | null
|
|
_min: SmsLogMinAggregateOutputType | null
|
|
_max: SmsLogMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type SmsLogMinAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
mobile: string | null
|
|
type: $Enums.SmsType | null
|
|
message: string | null
|
|
provider: string | null
|
|
status: $Enums.SmsStatus | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type SmsLogMaxAggregateOutputType = {
|
|
id: string | null
|
|
userId: string | null
|
|
mobile: string | null
|
|
type: $Enums.SmsType | null
|
|
message: string | null
|
|
provider: string | null
|
|
status: $Enums.SmsStatus | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type SmsLogCountAggregateOutputType = {
|
|
id: number
|
|
userId: number
|
|
mobile: number
|
|
type: number
|
|
message: number
|
|
provider: number
|
|
status: number
|
|
providerResponse: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type SmsLogMinAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
mobile?: true
|
|
type?: true
|
|
message?: true
|
|
provider?: true
|
|
status?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type SmsLogMaxAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
mobile?: true
|
|
type?: true
|
|
message?: true
|
|
provider?: true
|
|
status?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type SmsLogCountAggregateInputType = {
|
|
id?: true
|
|
userId?: true
|
|
mobile?: true
|
|
type?: true
|
|
message?: true
|
|
provider?: true
|
|
status?: true
|
|
providerResponse?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type SmsLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which SmsLog to aggregate.
|
|
*/
|
|
where?: SmsLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of SmsLogs to fetch.
|
|
*/
|
|
orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: SmsLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` SmsLogs 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` SmsLogs.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned SmsLogs
|
|
**/
|
|
_count?: true | SmsLogCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: SmsLogMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: SmsLogMaxAggregateInputType
|
|
}
|
|
|
|
export type GetSmsLogAggregateType<T extends SmsLogAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateSmsLog]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateSmsLog[P]>
|
|
: GetScalarType<T[P], AggregateSmsLog[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type SmsLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: SmsLogWhereInput
|
|
orderBy?: SmsLogOrderByWithAggregationInput | SmsLogOrderByWithAggregationInput[]
|
|
by: SmsLogScalarFieldEnum[] | SmsLogScalarFieldEnum
|
|
having?: SmsLogScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: SmsLogCountAggregateInputType | true
|
|
_min?: SmsLogMinAggregateInputType
|
|
_max?: SmsLogMaxAggregateInputType
|
|
}
|
|
|
|
export type SmsLogGroupByOutputType = {
|
|
id: string
|
|
userId: string | null
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider: string
|
|
status: $Enums.SmsStatus
|
|
providerResponse: JsonValue | null
|
|
createdAt: Date
|
|
_count: SmsLogCountAggregateOutputType | null
|
|
_min: SmsLogMinAggregateOutputType | null
|
|
_max: SmsLogMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetSmsLogGroupByPayload<T extends SmsLogGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<SmsLogGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof SmsLogGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], SmsLogGroupByOutputType[P]>
|
|
: GetScalarType<T[P], SmsLogGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type SmsLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
mobile?: boolean
|
|
type?: boolean
|
|
message?: boolean
|
|
provider?: boolean
|
|
status?: boolean
|
|
providerResponse?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | SmsLog$userArgs<ExtArgs>
|
|
}, ExtArgs["result"]["smsLog"]>
|
|
|
|
export type SmsLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
userId?: boolean
|
|
mobile?: boolean
|
|
type?: boolean
|
|
message?: boolean
|
|
provider?: boolean
|
|
status?: boolean
|
|
providerResponse?: boolean
|
|
createdAt?: boolean
|
|
user?: boolean | SmsLog$userArgs<ExtArgs>
|
|
}, ExtArgs["result"]["smsLog"]>
|
|
|
|
export type SmsLogSelectScalar = {
|
|
id?: boolean
|
|
userId?: boolean
|
|
mobile?: boolean
|
|
type?: boolean
|
|
message?: boolean
|
|
provider?: boolean
|
|
status?: boolean
|
|
providerResponse?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type SmsLogInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | SmsLog$userArgs<ExtArgs>
|
|
}
|
|
export type SmsLogIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
user?: boolean | SmsLog$userArgs<ExtArgs>
|
|
}
|
|
|
|
export type $SmsLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "SmsLog"
|
|
objects: {
|
|
user: Prisma.$UserPayload<ExtArgs> | null
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
userId: string | null
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider: string
|
|
status: $Enums.SmsStatus
|
|
providerResponse: Prisma.JsonValue | null
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["smsLog"]>
|
|
composites: {}
|
|
}
|
|
|
|
type SmsLogGetPayload<S extends boolean | null | undefined | SmsLogDefaultArgs> = $Result.GetResult<Prisma.$SmsLogPayload, S>
|
|
|
|
type SmsLogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<SmsLogFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: SmsLogCountAggregateInputType | true
|
|
}
|
|
|
|
export interface SmsLogDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['SmsLog'], meta: { name: 'SmsLog' } }
|
|
/**
|
|
* Find zero or one SmsLog that matches the filter.
|
|
* @param {SmsLogFindUniqueArgs} args - Arguments to find a SmsLog
|
|
* @example
|
|
* // Get one SmsLog
|
|
* const smsLog = await prisma.smsLog.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends SmsLogFindUniqueArgs>(args: SelectSubset<T, SmsLogFindUniqueArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one SmsLog that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {SmsLogFindUniqueOrThrowArgs} args - Arguments to find a SmsLog
|
|
* @example
|
|
* // Get one SmsLog
|
|
* const smsLog = await prisma.smsLog.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends SmsLogFindUniqueOrThrowArgs>(args: SelectSubset<T, SmsLogFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first SmsLog 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 {SmsLogFindFirstArgs} args - Arguments to find a SmsLog
|
|
* @example
|
|
* // Get one SmsLog
|
|
* const smsLog = await prisma.smsLog.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends SmsLogFindFirstArgs>(args?: SelectSubset<T, SmsLogFindFirstArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first SmsLog 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 {SmsLogFindFirstOrThrowArgs} args - Arguments to find a SmsLog
|
|
* @example
|
|
* // Get one SmsLog
|
|
* const smsLog = await prisma.smsLog.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends SmsLogFindFirstOrThrowArgs>(args?: SelectSubset<T, SmsLogFindFirstOrThrowArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more SmsLogs 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 {SmsLogFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all SmsLogs
|
|
* const smsLogs = await prisma.smsLog.findMany()
|
|
*
|
|
* // Get first 10 SmsLogs
|
|
* const smsLogs = await prisma.smsLog.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const smsLogWithIdOnly = await prisma.smsLog.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends SmsLogFindManyArgs>(args?: SelectSubset<T, SmsLogFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a SmsLog.
|
|
* @param {SmsLogCreateArgs} args - Arguments to create a SmsLog.
|
|
* @example
|
|
* // Create one SmsLog
|
|
* const SmsLog = await prisma.smsLog.create({
|
|
* data: {
|
|
* // ... data to create a SmsLog
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends SmsLogCreateArgs>(args: SelectSubset<T, SmsLogCreateArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many SmsLogs.
|
|
* @param {SmsLogCreateManyArgs} args - Arguments to create many SmsLogs.
|
|
* @example
|
|
* // Create many SmsLogs
|
|
* const smsLog = await prisma.smsLog.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends SmsLogCreateManyArgs>(args?: SelectSubset<T, SmsLogCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many SmsLogs and returns the data saved in the database.
|
|
* @param {SmsLogCreateManyAndReturnArgs} args - Arguments to create many SmsLogs.
|
|
* @example
|
|
* // Create many SmsLogs
|
|
* const smsLog = await prisma.smsLog.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many SmsLogs and only return the `id`
|
|
* const smsLogWithIdOnly = await prisma.smsLog.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 SmsLogCreateManyAndReturnArgs>(args?: SelectSubset<T, SmsLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a SmsLog.
|
|
* @param {SmsLogDeleteArgs} args - Arguments to delete one SmsLog.
|
|
* @example
|
|
* // Delete one SmsLog
|
|
* const SmsLog = await prisma.smsLog.delete({
|
|
* where: {
|
|
* // ... filter to delete one SmsLog
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends SmsLogDeleteArgs>(args: SelectSubset<T, SmsLogDeleteArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one SmsLog.
|
|
* @param {SmsLogUpdateArgs} args - Arguments to update one SmsLog.
|
|
* @example
|
|
* // Update one SmsLog
|
|
* const smsLog = await prisma.smsLog.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends SmsLogUpdateArgs>(args: SelectSubset<T, SmsLogUpdateArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more SmsLogs.
|
|
* @param {SmsLogDeleteManyArgs} args - Arguments to filter SmsLogs to delete.
|
|
* @example
|
|
* // Delete a few SmsLogs
|
|
* const { count } = await prisma.smsLog.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends SmsLogDeleteManyArgs>(args?: SelectSubset<T, SmsLogDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more SmsLogs.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SmsLogUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many SmsLogs
|
|
* const smsLog = await prisma.smsLog.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends SmsLogUpdateManyArgs>(args: SelectSubset<T, SmsLogUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one SmsLog.
|
|
* @param {SmsLogUpsertArgs} args - Arguments to update or create a SmsLog.
|
|
* @example
|
|
* // Update or create a SmsLog
|
|
* const smsLog = await prisma.smsLog.upsert({
|
|
* create: {
|
|
* // ... data to create a SmsLog
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the SmsLog we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends SmsLogUpsertArgs>(args: SelectSubset<T, SmsLogUpsertArgs<ExtArgs>>): Prisma__SmsLogClient<$Result.GetResult<Prisma.$SmsLogPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of SmsLogs.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SmsLogCountArgs} args - Arguments to filter SmsLogs to count.
|
|
* @example
|
|
* // Count the number of SmsLogs
|
|
* const count = await prisma.smsLog.count({
|
|
* where: {
|
|
* // ... the filter for the SmsLogs we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends SmsLogCountArgs>(
|
|
args?: Subset<T, SmsLogCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], SmsLogCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a SmsLog.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SmsLogAggregateArgs} 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 SmsLogAggregateArgs>(args: Subset<T, SmsLogAggregateArgs>): Prisma.PrismaPromise<GetSmsLogAggregateType<T>>
|
|
|
|
/**
|
|
* Group by SmsLog.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {SmsLogGroupByArgs} 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 SmsLogGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: SmsLogGroupByArgs['orderBy'] }
|
|
: { orderBy?: SmsLogGroupByArgs['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, SmsLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSmsLogGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the SmsLog model
|
|
*/
|
|
readonly fields: SmsLogFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for SmsLog.
|
|
* 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__SmsLogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
user<T extends SmsLog$userArgs<ExtArgs> = {}>(args?: Subset<T, SmsLog$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
|
|
/**
|
|
* 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 SmsLog model
|
|
*/
|
|
interface SmsLogFieldRefs {
|
|
readonly id: FieldRef<"SmsLog", 'String'>
|
|
readonly userId: FieldRef<"SmsLog", 'String'>
|
|
readonly mobile: FieldRef<"SmsLog", 'String'>
|
|
readonly type: FieldRef<"SmsLog", 'SmsType'>
|
|
readonly message: FieldRef<"SmsLog", 'String'>
|
|
readonly provider: FieldRef<"SmsLog", 'String'>
|
|
readonly status: FieldRef<"SmsLog", 'SmsStatus'>
|
|
readonly providerResponse: FieldRef<"SmsLog", 'Json'>
|
|
readonly createdAt: FieldRef<"SmsLog", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* SmsLog findUnique
|
|
*/
|
|
export type SmsLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which SmsLog to fetch.
|
|
*/
|
|
where: SmsLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog findUniqueOrThrow
|
|
*/
|
|
export type SmsLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which SmsLog to fetch.
|
|
*/
|
|
where: SmsLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog findFirst
|
|
*/
|
|
export type SmsLogFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which SmsLog to fetch.
|
|
*/
|
|
where?: SmsLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of SmsLogs to fetch.
|
|
*/
|
|
orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for SmsLogs.
|
|
*/
|
|
cursor?: SmsLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` SmsLogs 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` SmsLogs.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of SmsLogs.
|
|
*/
|
|
distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* SmsLog findFirstOrThrow
|
|
*/
|
|
export type SmsLogFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which SmsLog to fetch.
|
|
*/
|
|
where?: SmsLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of SmsLogs to fetch.
|
|
*/
|
|
orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for SmsLogs.
|
|
*/
|
|
cursor?: SmsLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` SmsLogs 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` SmsLogs.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of SmsLogs.
|
|
*/
|
|
distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* SmsLog findMany
|
|
*/
|
|
export type SmsLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which SmsLogs to fetch.
|
|
*/
|
|
where?: SmsLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of SmsLogs to fetch.
|
|
*/
|
|
orderBy?: SmsLogOrderByWithRelationInput | SmsLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing SmsLogs.
|
|
*/
|
|
cursor?: SmsLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` SmsLogs 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` SmsLogs.
|
|
*/
|
|
skip?: number
|
|
distinct?: SmsLogScalarFieldEnum | SmsLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* SmsLog create
|
|
*/
|
|
export type SmsLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a SmsLog.
|
|
*/
|
|
data: XOR<SmsLogCreateInput, SmsLogUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* SmsLog createMany
|
|
*/
|
|
export type SmsLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many SmsLogs.
|
|
*/
|
|
data: SmsLogCreateManyInput | SmsLogCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* SmsLog createManyAndReturn
|
|
*/
|
|
export type SmsLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many SmsLogs.
|
|
*/
|
|
data: SmsLogCreateManyInput | SmsLogCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* SmsLog update
|
|
*/
|
|
export type SmsLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a SmsLog.
|
|
*/
|
|
data: XOR<SmsLogUpdateInput, SmsLogUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which SmsLog to update.
|
|
*/
|
|
where: SmsLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog updateMany
|
|
*/
|
|
export type SmsLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update SmsLogs.
|
|
*/
|
|
data: XOR<SmsLogUpdateManyMutationInput, SmsLogUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which SmsLogs to update
|
|
*/
|
|
where?: SmsLogWhereInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog upsert
|
|
*/
|
|
export type SmsLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the SmsLog to update in case it exists.
|
|
*/
|
|
where: SmsLogWhereUniqueInput
|
|
/**
|
|
* In case the SmsLog found by the `where` argument doesn't exist, create a new SmsLog with this data.
|
|
*/
|
|
create: XOR<SmsLogCreateInput, SmsLogUncheckedCreateInput>
|
|
/**
|
|
* In case the SmsLog was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<SmsLogUpdateInput, SmsLogUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* SmsLog delete
|
|
*/
|
|
export type SmsLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which SmsLog to delete.
|
|
*/
|
|
where: SmsLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog deleteMany
|
|
*/
|
|
export type SmsLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which SmsLogs to delete
|
|
*/
|
|
where?: SmsLogWhereInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog.user
|
|
*/
|
|
export type SmsLog$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the User
|
|
*/
|
|
select?: UserSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UserInclude<ExtArgs> | null
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
/**
|
|
* SmsLog without action
|
|
*/
|
|
export type SmsLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the SmsLog
|
|
*/
|
|
select?: SmsLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: SmsLogInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model AdminLog
|
|
*/
|
|
|
|
export type AggregateAdminLog = {
|
|
_count: AdminLogCountAggregateOutputType | null
|
|
_min: AdminLogMinAggregateOutputType | null
|
|
_max: AdminLogMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type AdminLogMinAggregateOutputType = {
|
|
id: string | null
|
|
adminId: string | null
|
|
action: string | null
|
|
entityType: string | null
|
|
entityId: string | null
|
|
ip: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type AdminLogMaxAggregateOutputType = {
|
|
id: string | null
|
|
adminId: string | null
|
|
action: string | null
|
|
entityType: string | null
|
|
entityId: string | null
|
|
ip: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type AdminLogCountAggregateOutputType = {
|
|
id: number
|
|
adminId: number
|
|
action: number
|
|
entityType: number
|
|
entityId: number
|
|
oldValue: number
|
|
newValue: number
|
|
ip: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type AdminLogMinAggregateInputType = {
|
|
id?: true
|
|
adminId?: true
|
|
action?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
ip?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type AdminLogMaxAggregateInputType = {
|
|
id?: true
|
|
adminId?: true
|
|
action?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
ip?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type AdminLogCountAggregateInputType = {
|
|
id?: true
|
|
adminId?: true
|
|
action?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
oldValue?: true
|
|
newValue?: true
|
|
ip?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type AdminLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which AdminLog to aggregate.
|
|
*/
|
|
where?: AdminLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AdminLogs to fetch.
|
|
*/
|
|
orderBy?: AdminLogOrderByWithRelationInput | AdminLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: AdminLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AdminLogs 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` AdminLogs.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned AdminLogs
|
|
**/
|
|
_count?: true | AdminLogCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: AdminLogMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: AdminLogMaxAggregateInputType
|
|
}
|
|
|
|
export type GetAdminLogAggregateType<T extends AdminLogAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateAdminLog]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateAdminLog[P]>
|
|
: GetScalarType<T[P], AggregateAdminLog[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type AdminLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AdminLogWhereInput
|
|
orderBy?: AdminLogOrderByWithAggregationInput | AdminLogOrderByWithAggregationInput[]
|
|
by: AdminLogScalarFieldEnum[] | AdminLogScalarFieldEnum
|
|
having?: AdminLogScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: AdminLogCountAggregateInputType | true
|
|
_min?: AdminLogMinAggregateInputType
|
|
_max?: AdminLogMaxAggregateInputType
|
|
}
|
|
|
|
export type AdminLogGroupByOutputType = {
|
|
id: string
|
|
adminId: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue: JsonValue | null
|
|
newValue: JsonValue | null
|
|
ip: string | null
|
|
createdAt: Date
|
|
_count: AdminLogCountAggregateOutputType | null
|
|
_min: AdminLogMinAggregateOutputType | null
|
|
_max: AdminLogMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetAdminLogGroupByPayload<T extends AdminLogGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<AdminLogGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof AdminLogGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], AdminLogGroupByOutputType[P]>
|
|
: GetScalarType<T[P], AdminLogGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type AdminLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
adminId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
oldValue?: boolean
|
|
newValue?: boolean
|
|
ip?: boolean
|
|
createdAt?: boolean
|
|
admin?: boolean | AdminDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["adminLog"]>
|
|
|
|
export type AdminLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
adminId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
oldValue?: boolean
|
|
newValue?: boolean
|
|
ip?: boolean
|
|
createdAt?: boolean
|
|
admin?: boolean | AdminDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["adminLog"]>
|
|
|
|
export type AdminLogSelectScalar = {
|
|
id?: boolean
|
|
adminId?: boolean
|
|
action?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
oldValue?: boolean
|
|
newValue?: boolean
|
|
ip?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type AdminLogInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
admin?: boolean | AdminDefaultArgs<ExtArgs>
|
|
}
|
|
export type AdminLogIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
admin?: boolean | AdminDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $AdminLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "AdminLog"
|
|
objects: {
|
|
admin: Prisma.$AdminPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
adminId: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue: Prisma.JsonValue | null
|
|
newValue: Prisma.JsonValue | null
|
|
ip: string | null
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["adminLog"]>
|
|
composites: {}
|
|
}
|
|
|
|
type AdminLogGetPayload<S extends boolean | null | undefined | AdminLogDefaultArgs> = $Result.GetResult<Prisma.$AdminLogPayload, S>
|
|
|
|
type AdminLogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<AdminLogFindManyArgs, 'select' | 'include' | 'distinct'> & {
|
|
select?: AdminLogCountAggregateInputType | true
|
|
}
|
|
|
|
export interface AdminLogDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['AdminLog'], meta: { name: 'AdminLog' } }
|
|
/**
|
|
* Find zero or one AdminLog that matches the filter.
|
|
* @param {AdminLogFindUniqueArgs} args - Arguments to find a AdminLog
|
|
* @example
|
|
* // Get one AdminLog
|
|
* const adminLog = await prisma.adminLog.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends AdminLogFindUniqueArgs>(args: SelectSubset<T, AdminLogFindUniqueArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find one AdminLog that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {AdminLogFindUniqueOrThrowArgs} args - Arguments to find a AdminLog
|
|
* @example
|
|
* // Get one AdminLog
|
|
* const adminLog = await prisma.adminLog.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends AdminLogFindUniqueOrThrowArgs>(args: SelectSubset<T, AdminLogFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find the first AdminLog 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 {AdminLogFindFirstArgs} args - Arguments to find a AdminLog
|
|
* @example
|
|
* // Get one AdminLog
|
|
* const adminLog = await prisma.adminLog.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends AdminLogFindFirstArgs>(args?: SelectSubset<T, AdminLogFindFirstArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
|
|
|
|
/**
|
|
* Find the first AdminLog 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 {AdminLogFindFirstOrThrowArgs} args - Arguments to find a AdminLog
|
|
* @example
|
|
* // Get one AdminLog
|
|
* const adminLog = await prisma.adminLog.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends AdminLogFindFirstOrThrowArgs>(args?: SelectSubset<T, AdminLogFindFirstOrThrowArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
|
|
|
|
/**
|
|
* Find zero or more AdminLogs 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 {AdminLogFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all AdminLogs
|
|
* const adminLogs = await prisma.adminLog.findMany()
|
|
*
|
|
* // Get first 10 AdminLogs
|
|
* const adminLogs = await prisma.adminLog.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const adminLogWithIdOnly = await prisma.adminLog.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends AdminLogFindManyArgs>(args?: SelectSubset<T, AdminLogFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "findMany">>
|
|
|
|
/**
|
|
* Create a AdminLog.
|
|
* @param {AdminLogCreateArgs} args - Arguments to create a AdminLog.
|
|
* @example
|
|
* // Create one AdminLog
|
|
* const AdminLog = await prisma.adminLog.create({
|
|
* data: {
|
|
* // ... data to create a AdminLog
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends AdminLogCreateArgs>(args: SelectSubset<T, AdminLogCreateArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "create">, never, ExtArgs>
|
|
|
|
/**
|
|
* Create many AdminLogs.
|
|
* @param {AdminLogCreateManyArgs} args - Arguments to create many AdminLogs.
|
|
* @example
|
|
* // Create many AdminLogs
|
|
* const adminLog = await prisma.adminLog.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends AdminLogCreateManyArgs>(args?: SelectSubset<T, AdminLogCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many AdminLogs and returns the data saved in the database.
|
|
* @param {AdminLogCreateManyAndReturnArgs} args - Arguments to create many AdminLogs.
|
|
* @example
|
|
* // Create many AdminLogs
|
|
* const adminLog = await prisma.adminLog.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many AdminLogs and only return the `id`
|
|
* const adminLogWithIdOnly = await prisma.adminLog.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 AdminLogCreateManyAndReturnArgs>(args?: SelectSubset<T, AdminLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "createManyAndReturn">>
|
|
|
|
/**
|
|
* Delete a AdminLog.
|
|
* @param {AdminLogDeleteArgs} args - Arguments to delete one AdminLog.
|
|
* @example
|
|
* // Delete one AdminLog
|
|
* const AdminLog = await prisma.adminLog.delete({
|
|
* where: {
|
|
* // ... filter to delete one AdminLog
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends AdminLogDeleteArgs>(args: SelectSubset<T, AdminLogDeleteArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "delete">, never, ExtArgs>
|
|
|
|
/**
|
|
* Update one AdminLog.
|
|
* @param {AdminLogUpdateArgs} args - Arguments to update one AdminLog.
|
|
* @example
|
|
* // Update one AdminLog
|
|
* const adminLog = await prisma.adminLog.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends AdminLogUpdateArgs>(args: SelectSubset<T, AdminLogUpdateArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "update">, never, ExtArgs>
|
|
|
|
/**
|
|
* Delete zero or more AdminLogs.
|
|
* @param {AdminLogDeleteManyArgs} args - Arguments to filter AdminLogs to delete.
|
|
* @example
|
|
* // Delete a few AdminLogs
|
|
* const { count } = await prisma.adminLog.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends AdminLogDeleteManyArgs>(args?: SelectSubset<T, AdminLogDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more AdminLogs.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminLogUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many AdminLogs
|
|
* const adminLog = await prisma.adminLog.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends AdminLogUpdateManyArgs>(args: SelectSubset<T, AdminLogUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create or update one AdminLog.
|
|
* @param {AdminLogUpsertArgs} args - Arguments to update or create a AdminLog.
|
|
* @example
|
|
* // Update or create a AdminLog
|
|
* const adminLog = await prisma.adminLog.upsert({
|
|
* create: {
|
|
* // ... data to create a AdminLog
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the AdminLog we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends AdminLogUpsertArgs>(args: SelectSubset<T, AdminLogUpsertArgs<ExtArgs>>): Prisma__AdminLogClient<$Result.GetResult<Prisma.$AdminLogPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
|
|
|
|
|
|
/**
|
|
* Count the number of AdminLogs.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminLogCountArgs} args - Arguments to filter AdminLogs to count.
|
|
* @example
|
|
* // Count the number of AdminLogs
|
|
* const count = await prisma.adminLog.count({
|
|
* where: {
|
|
* // ... the filter for the AdminLogs we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends AdminLogCountArgs>(
|
|
args?: Subset<T, AdminLogCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], AdminLogCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a AdminLog.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminLogAggregateArgs} 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 AdminLogAggregateArgs>(args: Subset<T, AdminLogAggregateArgs>): Prisma.PrismaPromise<GetAdminLogAggregateType<T>>
|
|
|
|
/**
|
|
* Group by AdminLog.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AdminLogGroupByArgs} 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 AdminLogGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: AdminLogGroupByArgs['orderBy'] }
|
|
: { orderBy?: AdminLogGroupByArgs['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, AdminLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdminLogGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the AdminLog model
|
|
*/
|
|
readonly fields: AdminLogFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for AdminLog.
|
|
* 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__AdminLogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
admin<T extends AdminDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AdminDefaultArgs<ExtArgs>>): Prisma__AdminClient<$Result.GetResult<Prisma.$AdminPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
|
|
/**
|
|
* 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 AdminLog model
|
|
*/
|
|
interface AdminLogFieldRefs {
|
|
readonly id: FieldRef<"AdminLog", 'String'>
|
|
readonly adminId: FieldRef<"AdminLog", 'String'>
|
|
readonly action: FieldRef<"AdminLog", 'String'>
|
|
readonly entityType: FieldRef<"AdminLog", 'String'>
|
|
readonly entityId: FieldRef<"AdminLog", 'String'>
|
|
readonly oldValue: FieldRef<"AdminLog", 'Json'>
|
|
readonly newValue: FieldRef<"AdminLog", 'Json'>
|
|
readonly ip: FieldRef<"AdminLog", 'String'>
|
|
readonly createdAt: FieldRef<"AdminLog", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* AdminLog findUnique
|
|
*/
|
|
export type AdminLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which AdminLog to fetch.
|
|
*/
|
|
where: AdminLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AdminLog findUniqueOrThrow
|
|
*/
|
|
export type AdminLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which AdminLog to fetch.
|
|
*/
|
|
where: AdminLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AdminLog findFirst
|
|
*/
|
|
export type AdminLogFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which AdminLog to fetch.
|
|
*/
|
|
where?: AdminLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AdminLogs to fetch.
|
|
*/
|
|
orderBy?: AdminLogOrderByWithRelationInput | AdminLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for AdminLogs.
|
|
*/
|
|
cursor?: AdminLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AdminLogs 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` AdminLogs.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of AdminLogs.
|
|
*/
|
|
distinct?: AdminLogScalarFieldEnum | AdminLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* AdminLog findFirstOrThrow
|
|
*/
|
|
export type AdminLogFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which AdminLog to fetch.
|
|
*/
|
|
where?: AdminLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AdminLogs to fetch.
|
|
*/
|
|
orderBy?: AdminLogOrderByWithRelationInput | AdminLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for AdminLogs.
|
|
*/
|
|
cursor?: AdminLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AdminLogs 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` AdminLogs.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of AdminLogs.
|
|
*/
|
|
distinct?: AdminLogScalarFieldEnum | AdminLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* AdminLog findMany
|
|
*/
|
|
export type AdminLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which AdminLogs to fetch.
|
|
*/
|
|
where?: AdminLogWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of AdminLogs to fetch.
|
|
*/
|
|
orderBy?: AdminLogOrderByWithRelationInput | AdminLogOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing AdminLogs.
|
|
*/
|
|
cursor?: AdminLogWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` AdminLogs 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` AdminLogs.
|
|
*/
|
|
skip?: number
|
|
distinct?: AdminLogScalarFieldEnum | AdminLogScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* AdminLog create
|
|
*/
|
|
export type AdminLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a AdminLog.
|
|
*/
|
|
data: XOR<AdminLogCreateInput, AdminLogUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* AdminLog createMany
|
|
*/
|
|
export type AdminLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many AdminLogs.
|
|
*/
|
|
data: AdminLogCreateManyInput | AdminLogCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* AdminLog createManyAndReturn
|
|
*/
|
|
export type AdminLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* The data used to create many AdminLogs.
|
|
*/
|
|
data: AdminLogCreateManyInput | AdminLogCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* AdminLog update
|
|
*/
|
|
export type AdminLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a AdminLog.
|
|
*/
|
|
data: XOR<AdminLogUpdateInput, AdminLogUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which AdminLog to update.
|
|
*/
|
|
where: AdminLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AdminLog updateMany
|
|
*/
|
|
export type AdminLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update AdminLogs.
|
|
*/
|
|
data: XOR<AdminLogUpdateManyMutationInput, AdminLogUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which AdminLogs to update
|
|
*/
|
|
where?: AdminLogWhereInput
|
|
}
|
|
|
|
/**
|
|
* AdminLog upsert
|
|
*/
|
|
export type AdminLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the AdminLog to update in case it exists.
|
|
*/
|
|
where: AdminLogWhereUniqueInput
|
|
/**
|
|
* In case the AdminLog found by the `where` argument doesn't exist, create a new AdminLog with this data.
|
|
*/
|
|
create: XOR<AdminLogCreateInput, AdminLogUncheckedCreateInput>
|
|
/**
|
|
* In case the AdminLog was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<AdminLogUpdateInput, AdminLogUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* AdminLog delete
|
|
*/
|
|
export type AdminLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which AdminLog to delete.
|
|
*/
|
|
where: AdminLogWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* AdminLog deleteMany
|
|
*/
|
|
export type AdminLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which AdminLogs to delete
|
|
*/
|
|
where?: AdminLogWhereInput
|
|
}
|
|
|
|
/**
|
|
* AdminLog without action
|
|
*/
|
|
export type AdminLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the AdminLog
|
|
*/
|
|
select?: AdminLogSelect<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: AdminLogInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Enums
|
|
*/
|
|
|
|
export const TransactionIsolationLevel: {
|
|
ReadUncommitted: 'ReadUncommitted',
|
|
ReadCommitted: 'ReadCommitted',
|
|
RepeatableRead: 'RepeatableRead',
|
|
Serializable: 'Serializable'
|
|
};
|
|
|
|
export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
|
|
|
|
|
|
export const AdminScalarFieldEnum: {
|
|
id: 'id',
|
|
name: 'name',
|
|
mobile: 'mobile',
|
|
email: 'email',
|
|
passwordHash: 'passwordHash',
|
|
role: 'role',
|
|
status: 'status',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type AdminScalarFieldEnum = (typeof AdminScalarFieldEnum)[keyof typeof AdminScalarFieldEnum]
|
|
|
|
|
|
export const UserScalarFieldEnum: {
|
|
id: 'id',
|
|
mobile: 'mobile',
|
|
name: 'name',
|
|
status: 'status',
|
|
lastLoginAt: 'lastLoginAt',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
|
|
|
|
|
|
export const OtpCodeScalarFieldEnum: {
|
|
id: 'id',
|
|
mobile: 'mobile',
|
|
code: 'code',
|
|
userId: 'userId',
|
|
attempts: 'attempts',
|
|
consumed: 'consumed',
|
|
expiresAt: 'expiresAt',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type OtpCodeScalarFieldEnum = (typeof OtpCodeScalarFieldEnum)[keyof typeof OtpCodeScalarFieldEnum]
|
|
|
|
|
|
export const CampaignScalarFieldEnum: {
|
|
id: 'id',
|
|
title: 'title',
|
|
slug: 'slug',
|
|
description: 'description',
|
|
image: 'image',
|
|
banner: 'banner',
|
|
logo: 'logo',
|
|
startAt: 'startAt',
|
|
endAt: 'endAt',
|
|
status: 'status',
|
|
defaultChances: 'defaultChances',
|
|
rules: 'rules',
|
|
ctaText: 'ctaText',
|
|
wheelDesign: 'wheelDesign',
|
|
settings: 'settings',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type CampaignScalarFieldEnum = (typeof CampaignScalarFieldEnum)[keyof typeof CampaignScalarFieldEnum]
|
|
|
|
|
|
export const PrizeScalarFieldEnum: {
|
|
id: 'id',
|
|
campaignId: 'campaignId',
|
|
title: 'title',
|
|
description: 'description',
|
|
image: 'image',
|
|
type: 'type',
|
|
stockType: 'stockType',
|
|
initialStock: 'initialStock',
|
|
remainingStock: 'remainingStock',
|
|
weight: 'weight',
|
|
status: 'status',
|
|
sortOrder: 'sortOrder',
|
|
segmentColor: 'segmentColor',
|
|
expiresAt: 'expiresAt',
|
|
smsTemplate: 'smsTemplate',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type PrizeScalarFieldEnum = (typeof PrizeScalarFieldEnum)[keyof typeof PrizeScalarFieldEnum]
|
|
|
|
|
|
export const UserCampaignScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
campaignId: 'campaignId',
|
|
totalChances: 'totalChances',
|
|
usedChances: 'usedChances',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type UserCampaignScalarFieldEnum = (typeof UserCampaignScalarFieldEnum)[keyof typeof UserCampaignScalarFieldEnum]
|
|
|
|
|
|
export const ChanceTransactionScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
campaignId: 'campaignId',
|
|
amount: 'amount',
|
|
type: 'type',
|
|
referenceType: 'referenceType',
|
|
referenceId: 'referenceId',
|
|
description: 'description',
|
|
createdById: 'createdById',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type ChanceTransactionScalarFieldEnum = (typeof ChanceTransactionScalarFieldEnum)[keyof typeof ChanceTransactionScalarFieldEnum]
|
|
|
|
|
|
export const SpinScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
campaignId: 'campaignId',
|
|
prizeId: 'prizeId',
|
|
status: 'status',
|
|
idempotencyKey: 'idempotencyKey',
|
|
ip: 'ip',
|
|
userAgent: 'userAgent',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type SpinScalarFieldEnum = (typeof SpinScalarFieldEnum)[keyof typeof SpinScalarFieldEnum]
|
|
|
|
|
|
export const UserPrizeScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
campaignId: 'campaignId',
|
|
prizeId: 'prizeId',
|
|
spinId: 'spinId',
|
|
code: 'code',
|
|
status: 'status',
|
|
wonAt: 'wonAt',
|
|
redeemedAt: 'redeemedAt'
|
|
};
|
|
|
|
export type UserPrizeScalarFieldEnum = (typeof UserPrizeScalarFieldEnum)[keyof typeof UserPrizeScalarFieldEnum]
|
|
|
|
|
|
export const SmsLogScalarFieldEnum: {
|
|
id: 'id',
|
|
userId: 'userId',
|
|
mobile: 'mobile',
|
|
type: 'type',
|
|
message: 'message',
|
|
provider: 'provider',
|
|
status: 'status',
|
|
providerResponse: 'providerResponse',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type SmsLogScalarFieldEnum = (typeof SmsLogScalarFieldEnum)[keyof typeof SmsLogScalarFieldEnum]
|
|
|
|
|
|
export const AdminLogScalarFieldEnum: {
|
|
id: 'id',
|
|
adminId: 'adminId',
|
|
action: 'action',
|
|
entityType: 'entityType',
|
|
entityId: 'entityId',
|
|
oldValue: 'oldValue',
|
|
newValue: 'newValue',
|
|
ip: 'ip',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type AdminLogScalarFieldEnum = (typeof AdminLogScalarFieldEnum)[keyof typeof AdminLogScalarFieldEnum]
|
|
|
|
|
|
export const SortOrder: {
|
|
asc: 'asc',
|
|
desc: 'desc'
|
|
};
|
|
|
|
export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
|
|
|
|
|
|
export const NullableJsonNullValueInput: {
|
|
DbNull: typeof DbNull,
|
|
JsonNull: typeof JsonNull
|
|
};
|
|
|
|
export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]
|
|
|
|
|
|
export const QueryMode: {
|
|
default: 'default',
|
|
insensitive: 'insensitive'
|
|
};
|
|
|
|
export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
|
|
|
|
|
|
export const NullsOrder: {
|
|
first: 'first',
|
|
last: 'last'
|
|
};
|
|
|
|
export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
|
|
|
|
|
|
export const JsonNullValueFilter: {
|
|
DbNull: typeof DbNull,
|
|
JsonNull: typeof JsonNull,
|
|
AnyNull: typeof AnyNull
|
|
};
|
|
|
|
export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]
|
|
|
|
|
|
/**
|
|
* Field references
|
|
*/
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'String'
|
|
*/
|
|
export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'String[]'
|
|
*/
|
|
export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'AdminRole'
|
|
*/
|
|
export type EnumAdminRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminRole'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'AdminRole[]'
|
|
*/
|
|
export type ListEnumAdminRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminRole[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'AdminStatus'
|
|
*/
|
|
export type EnumAdminStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'AdminStatus[]'
|
|
*/
|
|
export type ListEnumAdminStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* 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 'UserStatus'
|
|
*/
|
|
export type EnumUserStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'UserStatus[]'
|
|
*/
|
|
export type ListEnumUserStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* 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 'Boolean'
|
|
*/
|
|
export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'CampaignStatus'
|
|
*/
|
|
export type EnumCampaignStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CampaignStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'CampaignStatus[]'
|
|
*/
|
|
export type ListEnumCampaignStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CampaignStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'WheelDesign'
|
|
*/
|
|
export type EnumWheelDesignFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WheelDesign'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'WheelDesign[]'
|
|
*/
|
|
export type ListEnumWheelDesignFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WheelDesign[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Json'
|
|
*/
|
|
export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'PrizeType'
|
|
*/
|
|
export type EnumPrizeTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PrizeType'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'PrizeType[]'
|
|
*/
|
|
export type ListEnumPrizeTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PrizeType[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'StockType'
|
|
*/
|
|
export type EnumStockTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'StockType'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'StockType[]'
|
|
*/
|
|
export type ListEnumStockTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'StockType[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'PrizeStatus'
|
|
*/
|
|
export type EnumPrizeStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PrizeStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'PrizeStatus[]'
|
|
*/
|
|
export type ListEnumPrizeStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PrizeStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'ChanceTxnType'
|
|
*/
|
|
export type EnumChanceTxnTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ChanceTxnType'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'ChanceTxnType[]'
|
|
*/
|
|
export type ListEnumChanceTxnTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ChanceTxnType[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'SpinStatus'
|
|
*/
|
|
export type EnumSpinStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SpinStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'SpinStatus[]'
|
|
*/
|
|
export type ListEnumSpinStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SpinStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'UserPrizeStatus'
|
|
*/
|
|
export type EnumUserPrizeStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserPrizeStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'UserPrizeStatus[]'
|
|
*/
|
|
export type ListEnumUserPrizeStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserPrizeStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'SmsType'
|
|
*/
|
|
export type EnumSmsTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SmsType'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'SmsType[]'
|
|
*/
|
|
export type ListEnumSmsTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SmsType[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'SmsStatus'
|
|
*/
|
|
export type EnumSmsStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SmsStatus'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'SmsStatus[]'
|
|
*/
|
|
export type ListEnumSmsStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SmsStatus[]'>
|
|
|
|
|
|
|
|
/**
|
|
* 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 AdminWhereInput = {
|
|
AND?: AdminWhereInput | AdminWhereInput[]
|
|
OR?: AdminWhereInput[]
|
|
NOT?: AdminWhereInput | AdminWhereInput[]
|
|
id?: StringFilter<"Admin"> | string
|
|
name?: StringFilter<"Admin"> | string
|
|
mobile?: StringFilter<"Admin"> | string
|
|
email?: StringFilter<"Admin"> | string
|
|
passwordHash?: StringFilter<"Admin"> | string
|
|
role?: EnumAdminRoleFilter<"Admin"> | $Enums.AdminRole
|
|
status?: EnumAdminStatusFilter<"Admin"> | $Enums.AdminStatus
|
|
createdAt?: DateTimeFilter<"Admin"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Admin"> | Date | string
|
|
auditLogs?: AdminLogListRelationFilter
|
|
chanceTxns?: ChanceTransactionListRelationFilter
|
|
}
|
|
|
|
export type AdminOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
mobile?: SortOrder
|
|
email?: SortOrder
|
|
passwordHash?: SortOrder
|
|
role?: SortOrder
|
|
status?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
auditLogs?: AdminLogOrderByRelationAggregateInput
|
|
chanceTxns?: ChanceTransactionOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type AdminWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
mobile?: string
|
|
email?: string
|
|
AND?: AdminWhereInput | AdminWhereInput[]
|
|
OR?: AdminWhereInput[]
|
|
NOT?: AdminWhereInput | AdminWhereInput[]
|
|
name?: StringFilter<"Admin"> | string
|
|
passwordHash?: StringFilter<"Admin"> | string
|
|
role?: EnumAdminRoleFilter<"Admin"> | $Enums.AdminRole
|
|
status?: EnumAdminStatusFilter<"Admin"> | $Enums.AdminStatus
|
|
createdAt?: DateTimeFilter<"Admin"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Admin"> | Date | string
|
|
auditLogs?: AdminLogListRelationFilter
|
|
chanceTxns?: ChanceTransactionListRelationFilter
|
|
}, "id" | "mobile" | "email">
|
|
|
|
export type AdminOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
mobile?: SortOrder
|
|
email?: SortOrder
|
|
passwordHash?: SortOrder
|
|
role?: SortOrder
|
|
status?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: AdminCountOrderByAggregateInput
|
|
_max?: AdminMaxOrderByAggregateInput
|
|
_min?: AdminMinOrderByAggregateInput
|
|
}
|
|
|
|
export type AdminScalarWhereWithAggregatesInput = {
|
|
AND?: AdminScalarWhereWithAggregatesInput | AdminScalarWhereWithAggregatesInput[]
|
|
OR?: AdminScalarWhereWithAggregatesInput[]
|
|
NOT?: AdminScalarWhereWithAggregatesInput | AdminScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Admin"> | string
|
|
name?: StringWithAggregatesFilter<"Admin"> | string
|
|
mobile?: StringWithAggregatesFilter<"Admin"> | string
|
|
email?: StringWithAggregatesFilter<"Admin"> | string
|
|
passwordHash?: StringWithAggregatesFilter<"Admin"> | string
|
|
role?: EnumAdminRoleWithAggregatesFilter<"Admin"> | $Enums.AdminRole
|
|
status?: EnumAdminStatusWithAggregatesFilter<"Admin"> | $Enums.AdminStatus
|
|
createdAt?: DateTimeWithAggregatesFilter<"Admin"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Admin"> | Date | string
|
|
}
|
|
|
|
export type UserWhereInput = {
|
|
AND?: UserWhereInput | UserWhereInput[]
|
|
OR?: UserWhereInput[]
|
|
NOT?: UserWhereInput | UserWhereInput[]
|
|
id?: StringFilter<"User"> | string
|
|
mobile?: StringFilter<"User"> | string
|
|
name?: StringNullableFilter<"User"> | string | null
|
|
status?: EnumUserStatusFilter<"User"> | $Enums.UserStatus
|
|
lastLoginAt?: DateTimeNullableFilter<"User"> | Date | string | null
|
|
createdAt?: DateTimeFilter<"User"> | Date | string
|
|
updatedAt?: DateTimeFilter<"User"> | Date | string
|
|
userCampaigns?: UserCampaignListRelationFilter
|
|
chanceTransactions?: ChanceTransactionListRelationFilter
|
|
spins?: SpinListRelationFilter
|
|
userPrizes?: UserPrizeListRelationFilter
|
|
otpCodes?: OtpCodeListRelationFilter
|
|
smsLogs?: SmsLogListRelationFilter
|
|
}
|
|
|
|
export type UserOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
name?: SortOrderInput | SortOrder
|
|
status?: SortOrder
|
|
lastLoginAt?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
userCampaigns?: UserCampaignOrderByRelationAggregateInput
|
|
chanceTransactions?: ChanceTransactionOrderByRelationAggregateInput
|
|
spins?: SpinOrderByRelationAggregateInput
|
|
userPrizes?: UserPrizeOrderByRelationAggregateInput
|
|
otpCodes?: OtpCodeOrderByRelationAggregateInput
|
|
smsLogs?: SmsLogOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type UserWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
mobile?: string
|
|
AND?: UserWhereInput | UserWhereInput[]
|
|
OR?: UserWhereInput[]
|
|
NOT?: UserWhereInput | UserWhereInput[]
|
|
name?: StringNullableFilter<"User"> | string | null
|
|
status?: EnumUserStatusFilter<"User"> | $Enums.UserStatus
|
|
lastLoginAt?: DateTimeNullableFilter<"User"> | Date | string | null
|
|
createdAt?: DateTimeFilter<"User"> | Date | string
|
|
updatedAt?: DateTimeFilter<"User"> | Date | string
|
|
userCampaigns?: UserCampaignListRelationFilter
|
|
chanceTransactions?: ChanceTransactionListRelationFilter
|
|
spins?: SpinListRelationFilter
|
|
userPrizes?: UserPrizeListRelationFilter
|
|
otpCodes?: OtpCodeListRelationFilter
|
|
smsLogs?: SmsLogListRelationFilter
|
|
}, "id" | "mobile">
|
|
|
|
export type UserOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
name?: SortOrderInput | SortOrder
|
|
status?: SortOrder
|
|
lastLoginAt?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: UserCountOrderByAggregateInput
|
|
_max?: UserMaxOrderByAggregateInput
|
|
_min?: UserMinOrderByAggregateInput
|
|
}
|
|
|
|
export type UserScalarWhereWithAggregatesInput = {
|
|
AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
|
|
OR?: UserScalarWhereWithAggregatesInput[]
|
|
NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"User"> | string
|
|
mobile?: StringWithAggregatesFilter<"User"> | string
|
|
name?: StringNullableWithAggregatesFilter<"User"> | string | null
|
|
status?: EnumUserStatusWithAggregatesFilter<"User"> | $Enums.UserStatus
|
|
lastLoginAt?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
|
|
}
|
|
|
|
export type OtpCodeWhereInput = {
|
|
AND?: OtpCodeWhereInput | OtpCodeWhereInput[]
|
|
OR?: OtpCodeWhereInput[]
|
|
NOT?: OtpCodeWhereInput | OtpCodeWhereInput[]
|
|
id?: StringFilter<"OtpCode"> | string
|
|
mobile?: StringFilter<"OtpCode"> | string
|
|
code?: StringFilter<"OtpCode"> | string
|
|
userId?: StringNullableFilter<"OtpCode"> | string | null
|
|
attempts?: IntFilter<"OtpCode"> | number
|
|
consumed?: BoolFilter<"OtpCode"> | boolean
|
|
expiresAt?: DateTimeFilter<"OtpCode"> | Date | string
|
|
createdAt?: DateTimeFilter<"OtpCode"> | Date | string
|
|
user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
|
|
}
|
|
|
|
export type OtpCodeOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
code?: SortOrder
|
|
userId?: SortOrderInput | SortOrder
|
|
attempts?: SortOrder
|
|
consumed?: SortOrder
|
|
expiresAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
}
|
|
|
|
export type OtpCodeWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: OtpCodeWhereInput | OtpCodeWhereInput[]
|
|
OR?: OtpCodeWhereInput[]
|
|
NOT?: OtpCodeWhereInput | OtpCodeWhereInput[]
|
|
mobile?: StringFilter<"OtpCode"> | string
|
|
code?: StringFilter<"OtpCode"> | string
|
|
userId?: StringNullableFilter<"OtpCode"> | string | null
|
|
attempts?: IntFilter<"OtpCode"> | number
|
|
consumed?: BoolFilter<"OtpCode"> | boolean
|
|
expiresAt?: DateTimeFilter<"OtpCode"> | Date | string
|
|
createdAt?: DateTimeFilter<"OtpCode"> | Date | string
|
|
user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
|
|
}, "id">
|
|
|
|
export type OtpCodeOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
code?: SortOrder
|
|
userId?: SortOrderInput | SortOrder
|
|
attempts?: SortOrder
|
|
consumed?: SortOrder
|
|
expiresAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: OtpCodeCountOrderByAggregateInput
|
|
_avg?: OtpCodeAvgOrderByAggregateInput
|
|
_max?: OtpCodeMaxOrderByAggregateInput
|
|
_min?: OtpCodeMinOrderByAggregateInput
|
|
_sum?: OtpCodeSumOrderByAggregateInput
|
|
}
|
|
|
|
export type OtpCodeScalarWhereWithAggregatesInput = {
|
|
AND?: OtpCodeScalarWhereWithAggregatesInput | OtpCodeScalarWhereWithAggregatesInput[]
|
|
OR?: OtpCodeScalarWhereWithAggregatesInput[]
|
|
NOT?: OtpCodeScalarWhereWithAggregatesInput | OtpCodeScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"OtpCode"> | string
|
|
mobile?: StringWithAggregatesFilter<"OtpCode"> | string
|
|
code?: StringWithAggregatesFilter<"OtpCode"> | string
|
|
userId?: StringNullableWithAggregatesFilter<"OtpCode"> | string | null
|
|
attempts?: IntWithAggregatesFilter<"OtpCode"> | number
|
|
consumed?: BoolWithAggregatesFilter<"OtpCode"> | boolean
|
|
expiresAt?: DateTimeWithAggregatesFilter<"OtpCode"> | Date | string
|
|
createdAt?: DateTimeWithAggregatesFilter<"OtpCode"> | Date | string
|
|
}
|
|
|
|
export type CampaignWhereInput = {
|
|
AND?: CampaignWhereInput | CampaignWhereInput[]
|
|
OR?: CampaignWhereInput[]
|
|
NOT?: CampaignWhereInput | CampaignWhereInput[]
|
|
id?: StringFilter<"Campaign"> | string
|
|
title?: StringFilter<"Campaign"> | string
|
|
slug?: StringFilter<"Campaign"> | string
|
|
description?: StringNullableFilter<"Campaign"> | string | null
|
|
image?: StringNullableFilter<"Campaign"> | string | null
|
|
banner?: StringNullableFilter<"Campaign"> | string | null
|
|
logo?: StringNullableFilter<"Campaign"> | string | null
|
|
startAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
endAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
status?: EnumCampaignStatusFilter<"Campaign"> | $Enums.CampaignStatus
|
|
defaultChances?: IntFilter<"Campaign"> | number
|
|
rules?: StringNullableFilter<"Campaign"> | string | null
|
|
ctaText?: StringNullableFilter<"Campaign"> | string | null
|
|
wheelDesign?: EnumWheelDesignFilter<"Campaign"> | $Enums.WheelDesign
|
|
settings?: JsonNullableFilter<"Campaign">
|
|
createdAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
prizes?: PrizeListRelationFilter
|
|
userCampaigns?: UserCampaignListRelationFilter
|
|
chanceTxns?: ChanceTransactionListRelationFilter
|
|
spins?: SpinListRelationFilter
|
|
userPrizes?: UserPrizeListRelationFilter
|
|
}
|
|
|
|
export type CampaignOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
slug?: SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
image?: SortOrderInput | SortOrder
|
|
banner?: SortOrderInput | SortOrder
|
|
logo?: SortOrderInput | SortOrder
|
|
startAt?: SortOrder
|
|
endAt?: SortOrder
|
|
status?: SortOrder
|
|
defaultChances?: SortOrder
|
|
rules?: SortOrderInput | SortOrder
|
|
ctaText?: SortOrderInput | SortOrder
|
|
wheelDesign?: SortOrder
|
|
settings?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
prizes?: PrizeOrderByRelationAggregateInput
|
|
userCampaigns?: UserCampaignOrderByRelationAggregateInput
|
|
chanceTxns?: ChanceTransactionOrderByRelationAggregateInput
|
|
spins?: SpinOrderByRelationAggregateInput
|
|
userPrizes?: UserPrizeOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type CampaignWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
slug?: string
|
|
AND?: CampaignWhereInput | CampaignWhereInput[]
|
|
OR?: CampaignWhereInput[]
|
|
NOT?: CampaignWhereInput | CampaignWhereInput[]
|
|
title?: StringFilter<"Campaign"> | string
|
|
description?: StringNullableFilter<"Campaign"> | string | null
|
|
image?: StringNullableFilter<"Campaign"> | string | null
|
|
banner?: StringNullableFilter<"Campaign"> | string | null
|
|
logo?: StringNullableFilter<"Campaign"> | string | null
|
|
startAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
endAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
status?: EnumCampaignStatusFilter<"Campaign"> | $Enums.CampaignStatus
|
|
defaultChances?: IntFilter<"Campaign"> | number
|
|
rules?: StringNullableFilter<"Campaign"> | string | null
|
|
ctaText?: StringNullableFilter<"Campaign"> | string | null
|
|
wheelDesign?: EnumWheelDesignFilter<"Campaign"> | $Enums.WheelDesign
|
|
settings?: JsonNullableFilter<"Campaign">
|
|
createdAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Campaign"> | Date | string
|
|
prizes?: PrizeListRelationFilter
|
|
userCampaigns?: UserCampaignListRelationFilter
|
|
chanceTxns?: ChanceTransactionListRelationFilter
|
|
spins?: SpinListRelationFilter
|
|
userPrizes?: UserPrizeListRelationFilter
|
|
}, "id" | "slug">
|
|
|
|
export type CampaignOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
slug?: SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
image?: SortOrderInput | SortOrder
|
|
banner?: SortOrderInput | SortOrder
|
|
logo?: SortOrderInput | SortOrder
|
|
startAt?: SortOrder
|
|
endAt?: SortOrder
|
|
status?: SortOrder
|
|
defaultChances?: SortOrder
|
|
rules?: SortOrderInput | SortOrder
|
|
ctaText?: SortOrderInput | SortOrder
|
|
wheelDesign?: SortOrder
|
|
settings?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: CampaignCountOrderByAggregateInput
|
|
_avg?: CampaignAvgOrderByAggregateInput
|
|
_max?: CampaignMaxOrderByAggregateInput
|
|
_min?: CampaignMinOrderByAggregateInput
|
|
_sum?: CampaignSumOrderByAggregateInput
|
|
}
|
|
|
|
export type CampaignScalarWhereWithAggregatesInput = {
|
|
AND?: CampaignScalarWhereWithAggregatesInput | CampaignScalarWhereWithAggregatesInput[]
|
|
OR?: CampaignScalarWhereWithAggregatesInput[]
|
|
NOT?: CampaignScalarWhereWithAggregatesInput | CampaignScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Campaign"> | string
|
|
title?: StringWithAggregatesFilter<"Campaign"> | string
|
|
slug?: StringWithAggregatesFilter<"Campaign"> | string
|
|
description?: StringNullableWithAggregatesFilter<"Campaign"> | string | null
|
|
image?: StringNullableWithAggregatesFilter<"Campaign"> | string | null
|
|
banner?: StringNullableWithAggregatesFilter<"Campaign"> | string | null
|
|
logo?: StringNullableWithAggregatesFilter<"Campaign"> | string | null
|
|
startAt?: DateTimeWithAggregatesFilter<"Campaign"> | Date | string
|
|
endAt?: DateTimeWithAggregatesFilter<"Campaign"> | Date | string
|
|
status?: EnumCampaignStatusWithAggregatesFilter<"Campaign"> | $Enums.CampaignStatus
|
|
defaultChances?: IntWithAggregatesFilter<"Campaign"> | number
|
|
rules?: StringNullableWithAggregatesFilter<"Campaign"> | string | null
|
|
ctaText?: StringNullableWithAggregatesFilter<"Campaign"> | string | null
|
|
wheelDesign?: EnumWheelDesignWithAggregatesFilter<"Campaign"> | $Enums.WheelDesign
|
|
settings?: JsonNullableWithAggregatesFilter<"Campaign">
|
|
createdAt?: DateTimeWithAggregatesFilter<"Campaign"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Campaign"> | Date | string
|
|
}
|
|
|
|
export type PrizeWhereInput = {
|
|
AND?: PrizeWhereInput | PrizeWhereInput[]
|
|
OR?: PrizeWhereInput[]
|
|
NOT?: PrizeWhereInput | PrizeWhereInput[]
|
|
id?: StringFilter<"Prize"> | string
|
|
campaignId?: StringFilter<"Prize"> | string
|
|
title?: StringFilter<"Prize"> | string
|
|
description?: StringNullableFilter<"Prize"> | string | null
|
|
image?: StringNullableFilter<"Prize"> | string | null
|
|
type?: EnumPrizeTypeFilter<"Prize"> | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFilter<"Prize"> | $Enums.StockType
|
|
initialStock?: IntNullableFilter<"Prize"> | number | null
|
|
remainingStock?: IntNullableFilter<"Prize"> | number | null
|
|
weight?: IntFilter<"Prize"> | number
|
|
status?: EnumPrizeStatusFilter<"Prize"> | $Enums.PrizeStatus
|
|
sortOrder?: IntFilter<"Prize"> | number
|
|
segmentColor?: StringFilter<"Prize"> | string
|
|
expiresAt?: DateTimeNullableFilter<"Prize"> | Date | string | null
|
|
smsTemplate?: StringNullableFilter<"Prize"> | string | null
|
|
createdAt?: DateTimeFilter<"Prize"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Prize"> | Date | string
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
spins?: SpinListRelationFilter
|
|
userPrizes?: UserPrizeListRelationFilter
|
|
}
|
|
|
|
export type PrizeOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
campaignId?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
image?: SortOrderInput | SortOrder
|
|
type?: SortOrder
|
|
stockType?: SortOrder
|
|
initialStock?: SortOrderInput | SortOrder
|
|
remainingStock?: SortOrderInput | SortOrder
|
|
weight?: SortOrder
|
|
status?: SortOrder
|
|
sortOrder?: SortOrder
|
|
segmentColor?: SortOrder
|
|
expiresAt?: SortOrderInput | SortOrder
|
|
smsTemplate?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
campaign?: CampaignOrderByWithRelationInput
|
|
spins?: SpinOrderByRelationAggregateInput
|
|
userPrizes?: UserPrizeOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type PrizeWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: PrizeWhereInput | PrizeWhereInput[]
|
|
OR?: PrizeWhereInput[]
|
|
NOT?: PrizeWhereInput | PrizeWhereInput[]
|
|
campaignId?: StringFilter<"Prize"> | string
|
|
title?: StringFilter<"Prize"> | string
|
|
description?: StringNullableFilter<"Prize"> | string | null
|
|
image?: StringNullableFilter<"Prize"> | string | null
|
|
type?: EnumPrizeTypeFilter<"Prize"> | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFilter<"Prize"> | $Enums.StockType
|
|
initialStock?: IntNullableFilter<"Prize"> | number | null
|
|
remainingStock?: IntNullableFilter<"Prize"> | number | null
|
|
weight?: IntFilter<"Prize"> | number
|
|
status?: EnumPrizeStatusFilter<"Prize"> | $Enums.PrizeStatus
|
|
sortOrder?: IntFilter<"Prize"> | number
|
|
segmentColor?: StringFilter<"Prize"> | string
|
|
expiresAt?: DateTimeNullableFilter<"Prize"> | Date | string | null
|
|
smsTemplate?: StringNullableFilter<"Prize"> | string | null
|
|
createdAt?: DateTimeFilter<"Prize"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Prize"> | Date | string
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
spins?: SpinListRelationFilter
|
|
userPrizes?: UserPrizeListRelationFilter
|
|
}, "id">
|
|
|
|
export type PrizeOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
campaignId?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
image?: SortOrderInput | SortOrder
|
|
type?: SortOrder
|
|
stockType?: SortOrder
|
|
initialStock?: SortOrderInput | SortOrder
|
|
remainingStock?: SortOrderInput | SortOrder
|
|
weight?: SortOrder
|
|
status?: SortOrder
|
|
sortOrder?: SortOrder
|
|
segmentColor?: SortOrder
|
|
expiresAt?: SortOrderInput | SortOrder
|
|
smsTemplate?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: PrizeCountOrderByAggregateInput
|
|
_avg?: PrizeAvgOrderByAggregateInput
|
|
_max?: PrizeMaxOrderByAggregateInput
|
|
_min?: PrizeMinOrderByAggregateInput
|
|
_sum?: PrizeSumOrderByAggregateInput
|
|
}
|
|
|
|
export type PrizeScalarWhereWithAggregatesInput = {
|
|
AND?: PrizeScalarWhereWithAggregatesInput | PrizeScalarWhereWithAggregatesInput[]
|
|
OR?: PrizeScalarWhereWithAggregatesInput[]
|
|
NOT?: PrizeScalarWhereWithAggregatesInput | PrizeScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Prize"> | string
|
|
campaignId?: StringWithAggregatesFilter<"Prize"> | string
|
|
title?: StringWithAggregatesFilter<"Prize"> | string
|
|
description?: StringNullableWithAggregatesFilter<"Prize"> | string | null
|
|
image?: StringNullableWithAggregatesFilter<"Prize"> | string | null
|
|
type?: EnumPrizeTypeWithAggregatesFilter<"Prize"> | $Enums.PrizeType
|
|
stockType?: EnumStockTypeWithAggregatesFilter<"Prize"> | $Enums.StockType
|
|
initialStock?: IntNullableWithAggregatesFilter<"Prize"> | number | null
|
|
remainingStock?: IntNullableWithAggregatesFilter<"Prize"> | number | null
|
|
weight?: IntWithAggregatesFilter<"Prize"> | number
|
|
status?: EnumPrizeStatusWithAggregatesFilter<"Prize"> | $Enums.PrizeStatus
|
|
sortOrder?: IntWithAggregatesFilter<"Prize"> | number
|
|
segmentColor?: StringWithAggregatesFilter<"Prize"> | string
|
|
expiresAt?: DateTimeNullableWithAggregatesFilter<"Prize"> | Date | string | null
|
|
smsTemplate?: StringNullableWithAggregatesFilter<"Prize"> | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"Prize"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Prize"> | Date | string
|
|
}
|
|
|
|
export type UserCampaignWhereInput = {
|
|
AND?: UserCampaignWhereInput | UserCampaignWhereInput[]
|
|
OR?: UserCampaignWhereInput[]
|
|
NOT?: UserCampaignWhereInput | UserCampaignWhereInput[]
|
|
id?: StringFilter<"UserCampaign"> | string
|
|
userId?: StringFilter<"UserCampaign"> | string
|
|
campaignId?: StringFilter<"UserCampaign"> | string
|
|
totalChances?: IntFilter<"UserCampaign"> | number
|
|
usedChances?: IntFilter<"UserCampaign"> | number
|
|
createdAt?: DateTimeFilter<"UserCampaign"> | Date | string
|
|
updatedAt?: DateTimeFilter<"UserCampaign"> | Date | string
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
}
|
|
|
|
export type UserCampaignOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
campaign?: CampaignOrderByWithRelationInput
|
|
}
|
|
|
|
export type UserCampaignWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
userId_campaignId?: UserCampaignUserIdCampaignIdCompoundUniqueInput
|
|
AND?: UserCampaignWhereInput | UserCampaignWhereInput[]
|
|
OR?: UserCampaignWhereInput[]
|
|
NOT?: UserCampaignWhereInput | UserCampaignWhereInput[]
|
|
userId?: StringFilter<"UserCampaign"> | string
|
|
campaignId?: StringFilter<"UserCampaign"> | string
|
|
totalChances?: IntFilter<"UserCampaign"> | number
|
|
usedChances?: IntFilter<"UserCampaign"> | number
|
|
createdAt?: DateTimeFilter<"UserCampaign"> | Date | string
|
|
updatedAt?: DateTimeFilter<"UserCampaign"> | Date | string
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
}, "id" | "userId_campaignId">
|
|
|
|
export type UserCampaignOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: UserCampaignCountOrderByAggregateInput
|
|
_avg?: UserCampaignAvgOrderByAggregateInput
|
|
_max?: UserCampaignMaxOrderByAggregateInput
|
|
_min?: UserCampaignMinOrderByAggregateInput
|
|
_sum?: UserCampaignSumOrderByAggregateInput
|
|
}
|
|
|
|
export type UserCampaignScalarWhereWithAggregatesInput = {
|
|
AND?: UserCampaignScalarWhereWithAggregatesInput | UserCampaignScalarWhereWithAggregatesInput[]
|
|
OR?: UserCampaignScalarWhereWithAggregatesInput[]
|
|
NOT?: UserCampaignScalarWhereWithAggregatesInput | UserCampaignScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"UserCampaign"> | string
|
|
userId?: StringWithAggregatesFilter<"UserCampaign"> | string
|
|
campaignId?: StringWithAggregatesFilter<"UserCampaign"> | string
|
|
totalChances?: IntWithAggregatesFilter<"UserCampaign"> | number
|
|
usedChances?: IntWithAggregatesFilter<"UserCampaign"> | number
|
|
createdAt?: DateTimeWithAggregatesFilter<"UserCampaign"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"UserCampaign"> | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionWhereInput = {
|
|
AND?: ChanceTransactionWhereInput | ChanceTransactionWhereInput[]
|
|
OR?: ChanceTransactionWhereInput[]
|
|
NOT?: ChanceTransactionWhereInput | ChanceTransactionWhereInput[]
|
|
id?: StringFilter<"ChanceTransaction"> | string
|
|
userId?: StringFilter<"ChanceTransaction"> | string
|
|
campaignId?: StringFilter<"ChanceTransaction"> | string
|
|
amount?: IntFilter<"ChanceTransaction"> | number
|
|
type?: EnumChanceTxnTypeFilter<"ChanceTransaction"> | $Enums.ChanceTxnType
|
|
referenceType?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
referenceId?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
description?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
createdById?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
createdAt?: DateTimeFilter<"ChanceTransaction"> | Date | string
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
createdBy?: XOR<AdminNullableRelationFilter, AdminWhereInput> | null
|
|
}
|
|
|
|
export type ChanceTransactionOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
amount?: SortOrder
|
|
type?: SortOrder
|
|
referenceType?: SortOrderInput | SortOrder
|
|
referenceId?: SortOrderInput | SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
createdById?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
campaign?: CampaignOrderByWithRelationInput
|
|
createdBy?: AdminOrderByWithRelationInput
|
|
}
|
|
|
|
export type ChanceTransactionWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: ChanceTransactionWhereInput | ChanceTransactionWhereInput[]
|
|
OR?: ChanceTransactionWhereInput[]
|
|
NOT?: ChanceTransactionWhereInput | ChanceTransactionWhereInput[]
|
|
userId?: StringFilter<"ChanceTransaction"> | string
|
|
campaignId?: StringFilter<"ChanceTransaction"> | string
|
|
amount?: IntFilter<"ChanceTransaction"> | number
|
|
type?: EnumChanceTxnTypeFilter<"ChanceTransaction"> | $Enums.ChanceTxnType
|
|
referenceType?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
referenceId?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
description?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
createdById?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
createdAt?: DateTimeFilter<"ChanceTransaction"> | Date | string
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
createdBy?: XOR<AdminNullableRelationFilter, AdminWhereInput> | null
|
|
}, "id">
|
|
|
|
export type ChanceTransactionOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
amount?: SortOrder
|
|
type?: SortOrder
|
|
referenceType?: SortOrderInput | SortOrder
|
|
referenceId?: SortOrderInput | SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
createdById?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: ChanceTransactionCountOrderByAggregateInput
|
|
_avg?: ChanceTransactionAvgOrderByAggregateInput
|
|
_max?: ChanceTransactionMaxOrderByAggregateInput
|
|
_min?: ChanceTransactionMinOrderByAggregateInput
|
|
_sum?: ChanceTransactionSumOrderByAggregateInput
|
|
}
|
|
|
|
export type ChanceTransactionScalarWhereWithAggregatesInput = {
|
|
AND?: ChanceTransactionScalarWhereWithAggregatesInput | ChanceTransactionScalarWhereWithAggregatesInput[]
|
|
OR?: ChanceTransactionScalarWhereWithAggregatesInput[]
|
|
NOT?: ChanceTransactionScalarWhereWithAggregatesInput | ChanceTransactionScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"ChanceTransaction"> | string
|
|
userId?: StringWithAggregatesFilter<"ChanceTransaction"> | string
|
|
campaignId?: StringWithAggregatesFilter<"ChanceTransaction"> | string
|
|
amount?: IntWithAggregatesFilter<"ChanceTransaction"> | number
|
|
type?: EnumChanceTxnTypeWithAggregatesFilter<"ChanceTransaction"> | $Enums.ChanceTxnType
|
|
referenceType?: StringNullableWithAggregatesFilter<"ChanceTransaction"> | string | null
|
|
referenceId?: StringNullableWithAggregatesFilter<"ChanceTransaction"> | string | null
|
|
description?: StringNullableWithAggregatesFilter<"ChanceTransaction"> | string | null
|
|
createdById?: StringNullableWithAggregatesFilter<"ChanceTransaction"> | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"ChanceTransaction"> | Date | string
|
|
}
|
|
|
|
export type SpinWhereInput = {
|
|
AND?: SpinWhereInput | SpinWhereInput[]
|
|
OR?: SpinWhereInput[]
|
|
NOT?: SpinWhereInput | SpinWhereInput[]
|
|
id?: StringFilter<"Spin"> | string
|
|
userId?: StringFilter<"Spin"> | string
|
|
campaignId?: StringFilter<"Spin"> | string
|
|
prizeId?: StringNullableFilter<"Spin"> | string | null
|
|
status?: EnumSpinStatusFilter<"Spin"> | $Enums.SpinStatus
|
|
idempotencyKey?: StringFilter<"Spin"> | string
|
|
ip?: StringNullableFilter<"Spin"> | string | null
|
|
userAgent?: StringNullableFilter<"Spin"> | string | null
|
|
createdAt?: DateTimeFilter<"Spin"> | Date | string
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
prize?: XOR<PrizeNullableRelationFilter, PrizeWhereInput> | null
|
|
userPrize?: XOR<UserPrizeNullableRelationFilter, UserPrizeWhereInput> | null
|
|
}
|
|
|
|
export type SpinOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrderInput | SortOrder
|
|
status?: SortOrder
|
|
idempotencyKey?: SortOrder
|
|
ip?: SortOrderInput | SortOrder
|
|
userAgent?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
campaign?: CampaignOrderByWithRelationInput
|
|
prize?: PrizeOrderByWithRelationInput
|
|
userPrize?: UserPrizeOrderByWithRelationInput
|
|
}
|
|
|
|
export type SpinWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
idempotencyKey?: string
|
|
AND?: SpinWhereInput | SpinWhereInput[]
|
|
OR?: SpinWhereInput[]
|
|
NOT?: SpinWhereInput | SpinWhereInput[]
|
|
userId?: StringFilter<"Spin"> | string
|
|
campaignId?: StringFilter<"Spin"> | string
|
|
prizeId?: StringNullableFilter<"Spin"> | string | null
|
|
status?: EnumSpinStatusFilter<"Spin"> | $Enums.SpinStatus
|
|
ip?: StringNullableFilter<"Spin"> | string | null
|
|
userAgent?: StringNullableFilter<"Spin"> | string | null
|
|
createdAt?: DateTimeFilter<"Spin"> | Date | string
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
prize?: XOR<PrizeNullableRelationFilter, PrizeWhereInput> | null
|
|
userPrize?: XOR<UserPrizeNullableRelationFilter, UserPrizeWhereInput> | null
|
|
}, "id" | "idempotencyKey">
|
|
|
|
export type SpinOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrderInput | SortOrder
|
|
status?: SortOrder
|
|
idempotencyKey?: SortOrder
|
|
ip?: SortOrderInput | SortOrder
|
|
userAgent?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: SpinCountOrderByAggregateInput
|
|
_max?: SpinMaxOrderByAggregateInput
|
|
_min?: SpinMinOrderByAggregateInput
|
|
}
|
|
|
|
export type SpinScalarWhereWithAggregatesInput = {
|
|
AND?: SpinScalarWhereWithAggregatesInput | SpinScalarWhereWithAggregatesInput[]
|
|
OR?: SpinScalarWhereWithAggregatesInput[]
|
|
NOT?: SpinScalarWhereWithAggregatesInput | SpinScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Spin"> | string
|
|
userId?: StringWithAggregatesFilter<"Spin"> | string
|
|
campaignId?: StringWithAggregatesFilter<"Spin"> | string
|
|
prizeId?: StringNullableWithAggregatesFilter<"Spin"> | string | null
|
|
status?: EnumSpinStatusWithAggregatesFilter<"Spin"> | $Enums.SpinStatus
|
|
idempotencyKey?: StringWithAggregatesFilter<"Spin"> | string
|
|
ip?: StringNullableWithAggregatesFilter<"Spin"> | string | null
|
|
userAgent?: StringNullableWithAggregatesFilter<"Spin"> | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"Spin"> | Date | string
|
|
}
|
|
|
|
export type UserPrizeWhereInput = {
|
|
AND?: UserPrizeWhereInput | UserPrizeWhereInput[]
|
|
OR?: UserPrizeWhereInput[]
|
|
NOT?: UserPrizeWhereInput | UserPrizeWhereInput[]
|
|
id?: StringFilter<"UserPrize"> | string
|
|
userId?: StringFilter<"UserPrize"> | string
|
|
campaignId?: StringFilter<"UserPrize"> | string
|
|
prizeId?: StringFilter<"UserPrize"> | string
|
|
spinId?: StringFilter<"UserPrize"> | string
|
|
code?: StringNullableFilter<"UserPrize"> | string | null
|
|
status?: EnumUserPrizeStatusFilter<"UserPrize"> | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFilter<"UserPrize"> | Date | string
|
|
redeemedAt?: DateTimeNullableFilter<"UserPrize"> | Date | string | null
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
prize?: XOR<PrizeRelationFilter, PrizeWhereInput>
|
|
spin?: XOR<SpinRelationFilter, SpinWhereInput>
|
|
}
|
|
|
|
export type UserPrizeOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
spinId?: SortOrder
|
|
code?: SortOrderInput | SortOrder
|
|
status?: SortOrder
|
|
wonAt?: SortOrder
|
|
redeemedAt?: SortOrderInput | SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
campaign?: CampaignOrderByWithRelationInput
|
|
prize?: PrizeOrderByWithRelationInput
|
|
spin?: SpinOrderByWithRelationInput
|
|
}
|
|
|
|
export type UserPrizeWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
spinId?: string
|
|
code?: string
|
|
AND?: UserPrizeWhereInput | UserPrizeWhereInput[]
|
|
OR?: UserPrizeWhereInput[]
|
|
NOT?: UserPrizeWhereInput | UserPrizeWhereInput[]
|
|
userId?: StringFilter<"UserPrize"> | string
|
|
campaignId?: StringFilter<"UserPrize"> | string
|
|
prizeId?: StringFilter<"UserPrize"> | string
|
|
status?: EnumUserPrizeStatusFilter<"UserPrize"> | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFilter<"UserPrize"> | Date | string
|
|
redeemedAt?: DateTimeNullableFilter<"UserPrize"> | Date | string | null
|
|
user?: XOR<UserRelationFilter, UserWhereInput>
|
|
campaign?: XOR<CampaignRelationFilter, CampaignWhereInput>
|
|
prize?: XOR<PrizeRelationFilter, PrizeWhereInput>
|
|
spin?: XOR<SpinRelationFilter, SpinWhereInput>
|
|
}, "id" | "spinId" | "code">
|
|
|
|
export type UserPrizeOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
spinId?: SortOrder
|
|
code?: SortOrderInput | SortOrder
|
|
status?: SortOrder
|
|
wonAt?: SortOrder
|
|
redeemedAt?: SortOrderInput | SortOrder
|
|
_count?: UserPrizeCountOrderByAggregateInput
|
|
_max?: UserPrizeMaxOrderByAggregateInput
|
|
_min?: UserPrizeMinOrderByAggregateInput
|
|
}
|
|
|
|
export type UserPrizeScalarWhereWithAggregatesInput = {
|
|
AND?: UserPrizeScalarWhereWithAggregatesInput | UserPrizeScalarWhereWithAggregatesInput[]
|
|
OR?: UserPrizeScalarWhereWithAggregatesInput[]
|
|
NOT?: UserPrizeScalarWhereWithAggregatesInput | UserPrizeScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"UserPrize"> | string
|
|
userId?: StringWithAggregatesFilter<"UserPrize"> | string
|
|
campaignId?: StringWithAggregatesFilter<"UserPrize"> | string
|
|
prizeId?: StringWithAggregatesFilter<"UserPrize"> | string
|
|
spinId?: StringWithAggregatesFilter<"UserPrize"> | string
|
|
code?: StringNullableWithAggregatesFilter<"UserPrize"> | string | null
|
|
status?: EnumUserPrizeStatusWithAggregatesFilter<"UserPrize"> | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeWithAggregatesFilter<"UserPrize"> | Date | string
|
|
redeemedAt?: DateTimeNullableWithAggregatesFilter<"UserPrize"> | Date | string | null
|
|
}
|
|
|
|
export type SmsLogWhereInput = {
|
|
AND?: SmsLogWhereInput | SmsLogWhereInput[]
|
|
OR?: SmsLogWhereInput[]
|
|
NOT?: SmsLogWhereInput | SmsLogWhereInput[]
|
|
id?: StringFilter<"SmsLog"> | string
|
|
userId?: StringNullableFilter<"SmsLog"> | string | null
|
|
mobile?: StringFilter<"SmsLog"> | string
|
|
type?: EnumSmsTypeFilter<"SmsLog"> | $Enums.SmsType
|
|
message?: StringFilter<"SmsLog"> | string
|
|
provider?: StringFilter<"SmsLog"> | string
|
|
status?: EnumSmsStatusFilter<"SmsLog"> | $Enums.SmsStatus
|
|
providerResponse?: JsonNullableFilter<"SmsLog">
|
|
createdAt?: DateTimeFilter<"SmsLog"> | Date | string
|
|
user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
|
|
}
|
|
|
|
export type SmsLogOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrderInput | SortOrder
|
|
mobile?: SortOrder
|
|
type?: SortOrder
|
|
message?: SortOrder
|
|
provider?: SortOrder
|
|
status?: SortOrder
|
|
providerResponse?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
user?: UserOrderByWithRelationInput
|
|
}
|
|
|
|
export type SmsLogWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: SmsLogWhereInput | SmsLogWhereInput[]
|
|
OR?: SmsLogWhereInput[]
|
|
NOT?: SmsLogWhereInput | SmsLogWhereInput[]
|
|
userId?: StringNullableFilter<"SmsLog"> | string | null
|
|
mobile?: StringFilter<"SmsLog"> | string
|
|
type?: EnumSmsTypeFilter<"SmsLog"> | $Enums.SmsType
|
|
message?: StringFilter<"SmsLog"> | string
|
|
provider?: StringFilter<"SmsLog"> | string
|
|
status?: EnumSmsStatusFilter<"SmsLog"> | $Enums.SmsStatus
|
|
providerResponse?: JsonNullableFilter<"SmsLog">
|
|
createdAt?: DateTimeFilter<"SmsLog"> | Date | string
|
|
user?: XOR<UserNullableRelationFilter, UserWhereInput> | null
|
|
}, "id">
|
|
|
|
export type SmsLogOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrderInput | SortOrder
|
|
mobile?: SortOrder
|
|
type?: SortOrder
|
|
message?: SortOrder
|
|
provider?: SortOrder
|
|
status?: SortOrder
|
|
providerResponse?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: SmsLogCountOrderByAggregateInput
|
|
_max?: SmsLogMaxOrderByAggregateInput
|
|
_min?: SmsLogMinOrderByAggregateInput
|
|
}
|
|
|
|
export type SmsLogScalarWhereWithAggregatesInput = {
|
|
AND?: SmsLogScalarWhereWithAggregatesInput | SmsLogScalarWhereWithAggregatesInput[]
|
|
OR?: SmsLogScalarWhereWithAggregatesInput[]
|
|
NOT?: SmsLogScalarWhereWithAggregatesInput | SmsLogScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"SmsLog"> | string
|
|
userId?: StringNullableWithAggregatesFilter<"SmsLog"> | string | null
|
|
mobile?: StringWithAggregatesFilter<"SmsLog"> | string
|
|
type?: EnumSmsTypeWithAggregatesFilter<"SmsLog"> | $Enums.SmsType
|
|
message?: StringWithAggregatesFilter<"SmsLog"> | string
|
|
provider?: StringWithAggregatesFilter<"SmsLog"> | string
|
|
status?: EnumSmsStatusWithAggregatesFilter<"SmsLog"> | $Enums.SmsStatus
|
|
providerResponse?: JsonNullableWithAggregatesFilter<"SmsLog">
|
|
createdAt?: DateTimeWithAggregatesFilter<"SmsLog"> | Date | string
|
|
}
|
|
|
|
export type AdminLogWhereInput = {
|
|
AND?: AdminLogWhereInput | AdminLogWhereInput[]
|
|
OR?: AdminLogWhereInput[]
|
|
NOT?: AdminLogWhereInput | AdminLogWhereInput[]
|
|
id?: StringFilter<"AdminLog"> | string
|
|
adminId?: StringFilter<"AdminLog"> | string
|
|
action?: StringFilter<"AdminLog"> | string
|
|
entityType?: StringFilter<"AdminLog"> | string
|
|
entityId?: StringFilter<"AdminLog"> | string
|
|
oldValue?: JsonNullableFilter<"AdminLog">
|
|
newValue?: JsonNullableFilter<"AdminLog">
|
|
ip?: StringNullableFilter<"AdminLog"> | string | null
|
|
createdAt?: DateTimeFilter<"AdminLog"> | Date | string
|
|
admin?: XOR<AdminRelationFilter, AdminWhereInput>
|
|
}
|
|
|
|
export type AdminLogOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
adminId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
oldValue?: SortOrderInput | SortOrder
|
|
newValue?: SortOrderInput | SortOrder
|
|
ip?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
admin?: AdminOrderByWithRelationInput
|
|
}
|
|
|
|
export type AdminLogWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: AdminLogWhereInput | AdminLogWhereInput[]
|
|
OR?: AdminLogWhereInput[]
|
|
NOT?: AdminLogWhereInput | AdminLogWhereInput[]
|
|
adminId?: StringFilter<"AdminLog"> | string
|
|
action?: StringFilter<"AdminLog"> | string
|
|
entityType?: StringFilter<"AdminLog"> | string
|
|
entityId?: StringFilter<"AdminLog"> | string
|
|
oldValue?: JsonNullableFilter<"AdminLog">
|
|
newValue?: JsonNullableFilter<"AdminLog">
|
|
ip?: StringNullableFilter<"AdminLog"> | string | null
|
|
createdAt?: DateTimeFilter<"AdminLog"> | Date | string
|
|
admin?: XOR<AdminRelationFilter, AdminWhereInput>
|
|
}, "id">
|
|
|
|
export type AdminLogOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
adminId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
oldValue?: SortOrderInput | SortOrder
|
|
newValue?: SortOrderInput | SortOrder
|
|
ip?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: AdminLogCountOrderByAggregateInput
|
|
_max?: AdminLogMaxOrderByAggregateInput
|
|
_min?: AdminLogMinOrderByAggregateInput
|
|
}
|
|
|
|
export type AdminLogScalarWhereWithAggregatesInput = {
|
|
AND?: AdminLogScalarWhereWithAggregatesInput | AdminLogScalarWhereWithAggregatesInput[]
|
|
OR?: AdminLogScalarWhereWithAggregatesInput[]
|
|
NOT?: AdminLogScalarWhereWithAggregatesInput | AdminLogScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"AdminLog"> | string
|
|
adminId?: StringWithAggregatesFilter<"AdminLog"> | string
|
|
action?: StringWithAggregatesFilter<"AdminLog"> | string
|
|
entityType?: StringWithAggregatesFilter<"AdminLog"> | string
|
|
entityId?: StringWithAggregatesFilter<"AdminLog"> | string
|
|
oldValue?: JsonNullableWithAggregatesFilter<"AdminLog">
|
|
newValue?: JsonNullableWithAggregatesFilter<"AdminLog">
|
|
ip?: StringNullableWithAggregatesFilter<"AdminLog"> | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"AdminLog"> | Date | string
|
|
}
|
|
|
|
export type AdminCreateInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
auditLogs?: AdminLogCreateNestedManyWithoutAdminInput
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCreatedByInput
|
|
}
|
|
|
|
export type AdminUncheckedCreateInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
auditLogs?: AdminLogUncheckedCreateNestedManyWithoutAdminInput
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCreatedByInput
|
|
}
|
|
|
|
export type AdminUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
auditLogs?: AdminLogUpdateManyWithoutAdminNestedInput
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCreatedByNestedInput
|
|
}
|
|
|
|
export type AdminUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
auditLogs?: AdminLogUncheckedUpdateManyWithoutAdminNestedInput
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCreatedByNestedInput
|
|
}
|
|
|
|
export type AdminCreateManyInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type AdminUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AdminUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCreateInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionCreateNestedManyWithoutUserInput
|
|
spins?: SpinCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionUncheckedCreateNestedManyWithoutUserInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeUncheckedCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUncheckedUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserCreateManyInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UserUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type OtpCodeCreateInput = {
|
|
id?: string
|
|
mobile: string
|
|
code: string
|
|
attempts?: number
|
|
consumed?: boolean
|
|
expiresAt: Date | string
|
|
createdAt?: Date | string
|
|
user?: UserCreateNestedOneWithoutOtpCodesInput
|
|
}
|
|
|
|
export type OtpCodeUncheckedCreateInput = {
|
|
id?: string
|
|
mobile: string
|
|
code: string
|
|
userId?: string | null
|
|
attempts?: number
|
|
consumed?: boolean
|
|
expiresAt: Date | string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type OtpCodeUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneWithoutOtpCodesNestedInput
|
|
}
|
|
|
|
export type OtpCodeUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
userId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type OtpCodeCreateManyInput = {
|
|
id?: string
|
|
mobile: string
|
|
code: string
|
|
userId?: string | null
|
|
attempts?: number
|
|
consumed?: boolean
|
|
expiresAt: Date | string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type OtpCodeUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type OtpCodeUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
userId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type CampaignCreateInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUncheckedCreateInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignCreateManyInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type CampaignUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PrizeCreateInput = {
|
|
id?: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
campaign: CampaignCreateNestedOneWithoutPrizesInput
|
|
spins?: SpinCreateNestedManyWithoutPrizeInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeUncheckedCreateInput = {
|
|
id?: string
|
|
campaignId: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
spins?: SpinUncheckedCreateNestedManyWithoutPrizeInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
campaign?: CampaignUpdateOneRequiredWithoutPrizesNestedInput
|
|
spins?: SpinUpdateManyWithoutPrizeNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
spins?: SpinUncheckedUpdateManyWithoutPrizeNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type PrizeCreateManyInput = {
|
|
id?: string
|
|
campaignId: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type PrizeUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateInput = {
|
|
id?: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
user: UserCreateNestedOneWithoutUserCampaignsInput
|
|
campaign: CampaignCreateNestedOneWithoutUserCampaignsInput
|
|
}
|
|
|
|
export type UserCampaignUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UserCampaignUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutUserCampaignsNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutUserCampaignsNestedInput
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UserCampaignUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateInput = {
|
|
id?: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutChanceTransactionsInput
|
|
campaign: CampaignCreateNestedOneWithoutChanceTxnsInput
|
|
createdBy?: AdminCreateNestedOneWithoutChanceTxnsInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdById?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutChanceTransactionsNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutChanceTxnsNestedInput
|
|
createdBy?: AdminUpdateOneWithoutChanceTxnsNestedInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdById?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdById?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdById?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SpinCreateInput = {
|
|
id?: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutSpinsInput
|
|
campaign: CampaignCreateNestedOneWithoutSpinsInput
|
|
prize?: PrizeCreateNestedOneWithoutSpinsInput
|
|
userPrize?: UserPrizeCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
userPrize?: UserPrizeUncheckedCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutSpinsNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutSpinsNestedInput
|
|
prize?: PrizeUpdateOneWithoutSpinsNestedInput
|
|
userPrize?: UserPrizeUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userPrize?: UserPrizeUncheckedUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SpinUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserPrizeCreateInput = {
|
|
id?: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
user: UserCreateNestedOneWithoutUserPrizesInput
|
|
campaign: CampaignCreateNestedOneWithoutUserPrizesInput
|
|
prize: PrizeCreateNestedOneWithoutUserPrizesInput
|
|
spin: SpinCreateNestedOneWithoutUserPrizeInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type UserPrizeUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
user?: UserUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
prize?: PrizeUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
spin?: SpinUpdateOneRequiredWithoutUserPrizeNestedInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type UserPrizeCreateManyInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type UserPrizeUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type SmsLogCreateInput = {
|
|
id?: string
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider?: string
|
|
status?: $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
user?: UserCreateNestedOneWithoutSmsLogsInput
|
|
}
|
|
|
|
export type SmsLogUncheckedCreateInput = {
|
|
id?: string
|
|
userId?: string | null
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider?: string
|
|
status?: $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SmsLogUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneWithoutSmsLogsNestedInput
|
|
}
|
|
|
|
export type SmsLogUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SmsLogCreateManyInput = {
|
|
id?: string
|
|
userId?: string | null
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider?: string
|
|
status?: $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SmsLogUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SmsLogUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AdminLogCreateInput = {
|
|
id?: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: string | null
|
|
createdAt?: Date | string
|
|
admin: AdminCreateNestedOneWithoutAuditLogsInput
|
|
}
|
|
|
|
export type AdminLogUncheckedCreateInput = {
|
|
id?: string
|
|
adminId: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AdminLogUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
admin?: AdminUpdateOneRequiredWithoutAuditLogsNestedInput
|
|
}
|
|
|
|
export type AdminLogUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
adminId?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AdminLogCreateManyInput = {
|
|
id?: string
|
|
adminId: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AdminLogUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AdminLogUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
adminId?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
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 EnumAdminRoleFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminRoleFilter<$PrismaModel> | $Enums.AdminRole
|
|
}
|
|
|
|
export type EnumAdminStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminStatus | EnumAdminStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminStatusFilter<$PrismaModel> | $Enums.AdminStatus
|
|
}
|
|
|
|
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 AdminLogListRelationFilter = {
|
|
every?: AdminLogWhereInput
|
|
some?: AdminLogWhereInput
|
|
none?: AdminLogWhereInput
|
|
}
|
|
|
|
export type ChanceTransactionListRelationFilter = {
|
|
every?: ChanceTransactionWhereInput
|
|
some?: ChanceTransactionWhereInput
|
|
none?: ChanceTransactionWhereInput
|
|
}
|
|
|
|
export type AdminLogOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type ChanceTransactionOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type AdminCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
mobile?: SortOrder
|
|
email?: SortOrder
|
|
passwordHash?: SortOrder
|
|
role?: SortOrder
|
|
status?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type AdminMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
mobile?: SortOrder
|
|
email?: SortOrder
|
|
passwordHash?: SortOrder
|
|
role?: SortOrder
|
|
status?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type AdminMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
mobile?: SortOrder
|
|
email?: SortOrder
|
|
passwordHash?: SortOrder
|
|
role?: SortOrder
|
|
status?: 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 EnumAdminRoleWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminRoleWithAggregatesFilter<$PrismaModel> | $Enums.AdminRole
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumAdminRoleFilter<$PrismaModel>
|
|
_max?: NestedEnumAdminRoleFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumAdminStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminStatus | EnumAdminStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminStatusWithAggregatesFilter<$PrismaModel> | $Enums.AdminStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumAdminStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumAdminStatusFilter<$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 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 EnumUserStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserStatus | EnumUserStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserStatusFilter<$PrismaModel> | $Enums.UserStatus
|
|
}
|
|
|
|
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 UserCampaignListRelationFilter = {
|
|
every?: UserCampaignWhereInput
|
|
some?: UserCampaignWhereInput
|
|
none?: UserCampaignWhereInput
|
|
}
|
|
|
|
export type SpinListRelationFilter = {
|
|
every?: SpinWhereInput
|
|
some?: SpinWhereInput
|
|
none?: SpinWhereInput
|
|
}
|
|
|
|
export type UserPrizeListRelationFilter = {
|
|
every?: UserPrizeWhereInput
|
|
some?: UserPrizeWhereInput
|
|
none?: UserPrizeWhereInput
|
|
}
|
|
|
|
export type OtpCodeListRelationFilter = {
|
|
every?: OtpCodeWhereInput
|
|
some?: OtpCodeWhereInput
|
|
none?: OtpCodeWhereInput
|
|
}
|
|
|
|
export type SmsLogListRelationFilter = {
|
|
every?: SmsLogWhereInput
|
|
some?: SmsLogWhereInput
|
|
none?: SmsLogWhereInput
|
|
}
|
|
|
|
export type SortOrderInput = {
|
|
sort: SortOrder
|
|
nulls?: NullsOrder
|
|
}
|
|
|
|
export type UserCampaignOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type SpinOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type UserPrizeOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type OtpCodeOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type SmsLogOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type UserCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
name?: SortOrder
|
|
status?: SortOrder
|
|
lastLoginAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UserMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
name?: SortOrder
|
|
status?: SortOrder
|
|
lastLoginAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UserMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
name?: SortOrder
|
|
status?: SortOrder
|
|
lastLoginAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: string | StringFieldRefInput<$PrismaModel> | null
|
|
in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
|
|
lt?: string | StringFieldRefInput<$PrismaModel>
|
|
lte?: string | StringFieldRefInput<$PrismaModel>
|
|
gt?: string | StringFieldRefInput<$PrismaModel>
|
|
gte?: string | StringFieldRefInput<$PrismaModel>
|
|
contains?: string | StringFieldRefInput<$PrismaModel>
|
|
startsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
endsWith?: string | StringFieldRefInput<$PrismaModel>
|
|
mode?: QueryMode
|
|
not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedStringNullableFilter<$PrismaModel>
|
|
_max?: NestedStringNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumUserStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserStatus | EnumUserStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserStatusWithAggregatesFilter<$PrismaModel> | $Enums.UserStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumUserStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumUserStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
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 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 BoolFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolFilter<$PrismaModel> | boolean
|
|
}
|
|
|
|
export type UserNullableRelationFilter = {
|
|
is?: UserWhereInput | null
|
|
isNot?: UserWhereInput | null
|
|
}
|
|
|
|
export type OtpCodeCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
code?: SortOrder
|
|
userId?: SortOrder
|
|
attempts?: SortOrder
|
|
consumed?: SortOrder
|
|
expiresAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type OtpCodeAvgOrderByAggregateInput = {
|
|
attempts?: SortOrder
|
|
}
|
|
|
|
export type OtpCodeMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
code?: SortOrder
|
|
userId?: SortOrder
|
|
attempts?: SortOrder
|
|
consumed?: SortOrder
|
|
expiresAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type OtpCodeMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
mobile?: SortOrder
|
|
code?: SortOrder
|
|
userId?: SortOrder
|
|
attempts?: SortOrder
|
|
consumed?: SortOrder
|
|
expiresAt?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type OtpCodeSumOrderByAggregateInput = {
|
|
attempts?: SortOrder
|
|
}
|
|
|
|
export type IntWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: number | IntFieldRefInput<$PrismaModel>
|
|
in?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
|
|
lt?: number | IntFieldRefInput<$PrismaModel>
|
|
lte?: number | IntFieldRefInput<$PrismaModel>
|
|
gt?: number | IntFieldRefInput<$PrismaModel>
|
|
gte?: number | IntFieldRefInput<$PrismaModel>
|
|
not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedIntFilter<$PrismaModel>
|
|
_max?: NestedIntFilter<$PrismaModel>
|
|
}
|
|
|
|
export type BoolWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedBoolFilter<$PrismaModel>
|
|
_max?: NestedBoolFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumCampaignStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CampaignStatus | EnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCampaignStatusFilter<$PrismaModel> | $Enums.CampaignStatus
|
|
}
|
|
|
|
export type EnumWheelDesignFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.WheelDesign | EnumWheelDesignFieldRefInput<$PrismaModel>
|
|
in?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumWheelDesignFilter<$PrismaModel> | $Enums.WheelDesign
|
|
}
|
|
export type JsonNullableFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<JsonNullableFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type JsonNullableFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: 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 PrizeListRelationFilter = {
|
|
every?: PrizeWhereInput
|
|
some?: PrizeWhereInput
|
|
none?: PrizeWhereInput
|
|
}
|
|
|
|
export type PrizeOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type CampaignCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
slug?: SortOrder
|
|
description?: SortOrder
|
|
image?: SortOrder
|
|
banner?: SortOrder
|
|
logo?: SortOrder
|
|
startAt?: SortOrder
|
|
endAt?: SortOrder
|
|
status?: SortOrder
|
|
defaultChances?: SortOrder
|
|
rules?: SortOrder
|
|
ctaText?: SortOrder
|
|
wheelDesign?: SortOrder
|
|
settings?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type CampaignAvgOrderByAggregateInput = {
|
|
defaultChances?: SortOrder
|
|
}
|
|
|
|
export type CampaignMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
slug?: SortOrder
|
|
description?: SortOrder
|
|
image?: SortOrder
|
|
banner?: SortOrder
|
|
logo?: SortOrder
|
|
startAt?: SortOrder
|
|
endAt?: SortOrder
|
|
status?: SortOrder
|
|
defaultChances?: SortOrder
|
|
rules?: SortOrder
|
|
ctaText?: SortOrder
|
|
wheelDesign?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type CampaignMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
title?: SortOrder
|
|
slug?: SortOrder
|
|
description?: SortOrder
|
|
image?: SortOrder
|
|
banner?: SortOrder
|
|
logo?: SortOrder
|
|
startAt?: SortOrder
|
|
endAt?: SortOrder
|
|
status?: SortOrder
|
|
defaultChances?: SortOrder
|
|
rules?: SortOrder
|
|
ctaText?: SortOrder
|
|
wheelDesign?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type CampaignSumOrderByAggregateInput = {
|
|
defaultChances?: SortOrder
|
|
}
|
|
|
|
export type EnumCampaignStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CampaignStatus | EnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCampaignStatusWithAggregatesFilter<$PrismaModel> | $Enums.CampaignStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumCampaignStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumCampaignStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumWheelDesignWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.WheelDesign | EnumWheelDesignFieldRefInput<$PrismaModel>
|
|
in?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumWheelDesignWithAggregatesFilter<$PrismaModel> | $Enums.WheelDesign
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumWheelDesignFilter<$PrismaModel>
|
|
_max?: NestedEnumWheelDesignFilter<$PrismaModel>
|
|
}
|
|
export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
|
|
not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedJsonNullableFilter<$PrismaModel>
|
|
_max?: NestedJsonNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumPrizeTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeType | EnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeTypeFilter<$PrismaModel> | $Enums.PrizeType
|
|
}
|
|
|
|
export type EnumStockTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.StockType | EnumStockTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumStockTypeFilter<$PrismaModel> | $Enums.StockType
|
|
}
|
|
|
|
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 EnumPrizeStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeStatus | EnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeStatusFilter<$PrismaModel> | $Enums.PrizeStatus
|
|
}
|
|
|
|
export type CampaignRelationFilter = {
|
|
is?: CampaignWhereInput
|
|
isNot?: CampaignWhereInput
|
|
}
|
|
|
|
export type PrizeCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
campaignId?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
image?: SortOrder
|
|
type?: SortOrder
|
|
stockType?: SortOrder
|
|
initialStock?: SortOrder
|
|
remainingStock?: SortOrder
|
|
weight?: SortOrder
|
|
status?: SortOrder
|
|
sortOrder?: SortOrder
|
|
segmentColor?: SortOrder
|
|
expiresAt?: SortOrder
|
|
smsTemplate?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type PrizeAvgOrderByAggregateInput = {
|
|
initialStock?: SortOrder
|
|
remainingStock?: SortOrder
|
|
weight?: SortOrder
|
|
sortOrder?: SortOrder
|
|
}
|
|
|
|
export type PrizeMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
campaignId?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
image?: SortOrder
|
|
type?: SortOrder
|
|
stockType?: SortOrder
|
|
initialStock?: SortOrder
|
|
remainingStock?: SortOrder
|
|
weight?: SortOrder
|
|
status?: SortOrder
|
|
sortOrder?: SortOrder
|
|
segmentColor?: SortOrder
|
|
expiresAt?: SortOrder
|
|
smsTemplate?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type PrizeMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
campaignId?: SortOrder
|
|
title?: SortOrder
|
|
description?: SortOrder
|
|
image?: SortOrder
|
|
type?: SortOrder
|
|
stockType?: SortOrder
|
|
initialStock?: SortOrder
|
|
remainingStock?: SortOrder
|
|
weight?: SortOrder
|
|
status?: SortOrder
|
|
sortOrder?: SortOrder
|
|
segmentColor?: SortOrder
|
|
expiresAt?: SortOrder
|
|
smsTemplate?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type PrizeSumOrderByAggregateInput = {
|
|
initialStock?: SortOrder
|
|
remainingStock?: SortOrder
|
|
weight?: SortOrder
|
|
sortOrder?: SortOrder
|
|
}
|
|
|
|
export type EnumPrizeTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeType | EnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeTypeWithAggregatesFilter<$PrismaModel> | $Enums.PrizeType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumPrizeTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumPrizeTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumStockTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.StockType | EnumStockTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumStockTypeWithAggregatesFilter<$PrismaModel> | $Enums.StockType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumStockTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumStockTypeFilter<$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 EnumPrizeStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeStatus | EnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeStatusWithAggregatesFilter<$PrismaModel> | $Enums.PrizeStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumPrizeStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumPrizeStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type UserRelationFilter = {
|
|
is?: UserWhereInput
|
|
isNot?: UserWhereInput
|
|
}
|
|
|
|
export type UserCampaignUserIdCampaignIdCompoundUniqueInput = {
|
|
userId: string
|
|
campaignId: string
|
|
}
|
|
|
|
export type UserCampaignCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UserCampaignAvgOrderByAggregateInput = {
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
}
|
|
|
|
export type UserCampaignMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UserCampaignMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UserCampaignSumOrderByAggregateInput = {
|
|
totalChances?: SortOrder
|
|
usedChances?: SortOrder
|
|
}
|
|
|
|
export type EnumChanceTxnTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.ChanceTxnType | EnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumChanceTxnTypeFilter<$PrismaModel> | $Enums.ChanceTxnType
|
|
}
|
|
|
|
export type AdminNullableRelationFilter = {
|
|
is?: AdminWhereInput | null
|
|
isNot?: AdminWhereInput | null
|
|
}
|
|
|
|
export type ChanceTransactionCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
amount?: SortOrder
|
|
type?: SortOrder
|
|
referenceType?: SortOrder
|
|
referenceId?: SortOrder
|
|
description?: SortOrder
|
|
createdById?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type ChanceTransactionAvgOrderByAggregateInput = {
|
|
amount?: SortOrder
|
|
}
|
|
|
|
export type ChanceTransactionMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
amount?: SortOrder
|
|
type?: SortOrder
|
|
referenceType?: SortOrder
|
|
referenceId?: SortOrder
|
|
description?: SortOrder
|
|
createdById?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type ChanceTransactionMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
amount?: SortOrder
|
|
type?: SortOrder
|
|
referenceType?: SortOrder
|
|
referenceId?: SortOrder
|
|
description?: SortOrder
|
|
createdById?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type ChanceTransactionSumOrderByAggregateInput = {
|
|
amount?: SortOrder
|
|
}
|
|
|
|
export type EnumChanceTxnTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.ChanceTxnType | EnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumChanceTxnTypeWithAggregatesFilter<$PrismaModel> | $Enums.ChanceTxnType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumChanceTxnTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumChanceTxnTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumSpinStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SpinStatus | EnumSpinStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSpinStatusFilter<$PrismaModel> | $Enums.SpinStatus
|
|
}
|
|
|
|
export type PrizeNullableRelationFilter = {
|
|
is?: PrizeWhereInput | null
|
|
isNot?: PrizeWhereInput | null
|
|
}
|
|
|
|
export type UserPrizeNullableRelationFilter = {
|
|
is?: UserPrizeWhereInput | null
|
|
isNot?: UserPrizeWhereInput | null
|
|
}
|
|
|
|
export type SpinCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
status?: SortOrder
|
|
idempotencyKey?: SortOrder
|
|
ip?: SortOrder
|
|
userAgent?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type SpinMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
status?: SortOrder
|
|
idempotencyKey?: SortOrder
|
|
ip?: SortOrder
|
|
userAgent?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type SpinMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
status?: SortOrder
|
|
idempotencyKey?: SortOrder
|
|
ip?: SortOrder
|
|
userAgent?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type EnumSpinStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SpinStatus | EnumSpinStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSpinStatusWithAggregatesFilter<$PrismaModel> | $Enums.SpinStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumSpinStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumSpinStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumUserPrizeStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserPrizeStatus | EnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserPrizeStatusFilter<$PrismaModel> | $Enums.UserPrizeStatus
|
|
}
|
|
|
|
export type PrizeRelationFilter = {
|
|
is?: PrizeWhereInput
|
|
isNot?: PrizeWhereInput
|
|
}
|
|
|
|
export type SpinRelationFilter = {
|
|
is?: SpinWhereInput
|
|
isNot?: SpinWhereInput
|
|
}
|
|
|
|
export type UserPrizeCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
spinId?: SortOrder
|
|
code?: SortOrder
|
|
status?: SortOrder
|
|
wonAt?: SortOrder
|
|
redeemedAt?: SortOrder
|
|
}
|
|
|
|
export type UserPrizeMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
spinId?: SortOrder
|
|
code?: SortOrder
|
|
status?: SortOrder
|
|
wonAt?: SortOrder
|
|
redeemedAt?: SortOrder
|
|
}
|
|
|
|
export type UserPrizeMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
campaignId?: SortOrder
|
|
prizeId?: SortOrder
|
|
spinId?: SortOrder
|
|
code?: SortOrder
|
|
status?: SortOrder
|
|
wonAt?: SortOrder
|
|
redeemedAt?: SortOrder
|
|
}
|
|
|
|
export type EnumUserPrizeStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserPrizeStatus | EnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserPrizeStatusWithAggregatesFilter<$PrismaModel> | $Enums.UserPrizeStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumUserPrizeStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumUserPrizeStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumSmsTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsType | EnumSmsTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsTypeFilter<$PrismaModel> | $Enums.SmsType
|
|
}
|
|
|
|
export type EnumSmsStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsStatus | EnumSmsStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsStatusFilter<$PrismaModel> | $Enums.SmsStatus
|
|
}
|
|
|
|
export type SmsLogCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
mobile?: SortOrder
|
|
type?: SortOrder
|
|
message?: SortOrder
|
|
provider?: SortOrder
|
|
status?: SortOrder
|
|
providerResponse?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type SmsLogMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
mobile?: SortOrder
|
|
type?: SortOrder
|
|
message?: SortOrder
|
|
provider?: SortOrder
|
|
status?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type SmsLogMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
userId?: SortOrder
|
|
mobile?: SortOrder
|
|
type?: SortOrder
|
|
message?: SortOrder
|
|
provider?: SortOrder
|
|
status?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type EnumSmsTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsType | EnumSmsTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsTypeWithAggregatesFilter<$PrismaModel> | $Enums.SmsType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumSmsTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumSmsTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type EnumSmsStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsStatus | EnumSmsStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsStatusWithAggregatesFilter<$PrismaModel> | $Enums.SmsStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumSmsStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumSmsStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type AdminRelationFilter = {
|
|
is?: AdminWhereInput
|
|
isNot?: AdminWhereInput
|
|
}
|
|
|
|
export type AdminLogCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
adminId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
oldValue?: SortOrder
|
|
newValue?: SortOrder
|
|
ip?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type AdminLogMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
adminId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
ip?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type AdminLogMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
adminId?: SortOrder
|
|
action?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
ip?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type AdminLogCreateNestedManyWithoutAdminInput = {
|
|
create?: XOR<AdminLogCreateWithoutAdminInput, AdminLogUncheckedCreateWithoutAdminInput> | AdminLogCreateWithoutAdminInput[] | AdminLogUncheckedCreateWithoutAdminInput[]
|
|
connectOrCreate?: AdminLogCreateOrConnectWithoutAdminInput | AdminLogCreateOrConnectWithoutAdminInput[]
|
|
createMany?: AdminLogCreateManyAdminInputEnvelope
|
|
connect?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
}
|
|
|
|
export type ChanceTransactionCreateNestedManyWithoutCreatedByInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCreatedByInput, ChanceTransactionUncheckedCreateWithoutCreatedByInput> | ChanceTransactionCreateWithoutCreatedByInput[] | ChanceTransactionUncheckedCreateWithoutCreatedByInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCreatedByInput | ChanceTransactionCreateOrConnectWithoutCreatedByInput[]
|
|
createMany?: ChanceTransactionCreateManyCreatedByInputEnvelope
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
}
|
|
|
|
export type AdminLogUncheckedCreateNestedManyWithoutAdminInput = {
|
|
create?: XOR<AdminLogCreateWithoutAdminInput, AdminLogUncheckedCreateWithoutAdminInput> | AdminLogCreateWithoutAdminInput[] | AdminLogUncheckedCreateWithoutAdminInput[]
|
|
connectOrCreate?: AdminLogCreateOrConnectWithoutAdminInput | AdminLogCreateOrConnectWithoutAdminInput[]
|
|
createMany?: AdminLogCreateManyAdminInputEnvelope
|
|
connect?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateNestedManyWithoutCreatedByInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCreatedByInput, ChanceTransactionUncheckedCreateWithoutCreatedByInput> | ChanceTransactionCreateWithoutCreatedByInput[] | ChanceTransactionUncheckedCreateWithoutCreatedByInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCreatedByInput | ChanceTransactionCreateOrConnectWithoutCreatedByInput[]
|
|
createMany?: ChanceTransactionCreateManyCreatedByInputEnvelope
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
}
|
|
|
|
export type StringFieldUpdateOperationsInput = {
|
|
set?: string
|
|
}
|
|
|
|
export type EnumAdminRoleFieldUpdateOperationsInput = {
|
|
set?: $Enums.AdminRole
|
|
}
|
|
|
|
export type EnumAdminStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.AdminStatus
|
|
}
|
|
|
|
export type DateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string
|
|
}
|
|
|
|
export type AdminLogUpdateManyWithoutAdminNestedInput = {
|
|
create?: XOR<AdminLogCreateWithoutAdminInput, AdminLogUncheckedCreateWithoutAdminInput> | AdminLogCreateWithoutAdminInput[] | AdminLogUncheckedCreateWithoutAdminInput[]
|
|
connectOrCreate?: AdminLogCreateOrConnectWithoutAdminInput | AdminLogCreateOrConnectWithoutAdminInput[]
|
|
upsert?: AdminLogUpsertWithWhereUniqueWithoutAdminInput | AdminLogUpsertWithWhereUniqueWithoutAdminInput[]
|
|
createMany?: AdminLogCreateManyAdminInputEnvelope
|
|
set?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
disconnect?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
delete?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
connect?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
update?: AdminLogUpdateWithWhereUniqueWithoutAdminInput | AdminLogUpdateWithWhereUniqueWithoutAdminInput[]
|
|
updateMany?: AdminLogUpdateManyWithWhereWithoutAdminInput | AdminLogUpdateManyWithWhereWithoutAdminInput[]
|
|
deleteMany?: AdminLogScalarWhereInput | AdminLogScalarWhereInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyWithoutCreatedByNestedInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCreatedByInput, ChanceTransactionUncheckedCreateWithoutCreatedByInput> | ChanceTransactionCreateWithoutCreatedByInput[] | ChanceTransactionUncheckedCreateWithoutCreatedByInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCreatedByInput | ChanceTransactionCreateOrConnectWithoutCreatedByInput[]
|
|
upsert?: ChanceTransactionUpsertWithWhereUniqueWithoutCreatedByInput | ChanceTransactionUpsertWithWhereUniqueWithoutCreatedByInput[]
|
|
createMany?: ChanceTransactionCreateManyCreatedByInputEnvelope
|
|
set?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
disconnect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
delete?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
update?: ChanceTransactionUpdateWithWhereUniqueWithoutCreatedByInput | ChanceTransactionUpdateWithWhereUniqueWithoutCreatedByInput[]
|
|
updateMany?: ChanceTransactionUpdateManyWithWhereWithoutCreatedByInput | ChanceTransactionUpdateManyWithWhereWithoutCreatedByInput[]
|
|
deleteMany?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
}
|
|
|
|
export type AdminLogUncheckedUpdateManyWithoutAdminNestedInput = {
|
|
create?: XOR<AdminLogCreateWithoutAdminInput, AdminLogUncheckedCreateWithoutAdminInput> | AdminLogCreateWithoutAdminInput[] | AdminLogUncheckedCreateWithoutAdminInput[]
|
|
connectOrCreate?: AdminLogCreateOrConnectWithoutAdminInput | AdminLogCreateOrConnectWithoutAdminInput[]
|
|
upsert?: AdminLogUpsertWithWhereUniqueWithoutAdminInput | AdminLogUpsertWithWhereUniqueWithoutAdminInput[]
|
|
createMany?: AdminLogCreateManyAdminInputEnvelope
|
|
set?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
disconnect?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
delete?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
connect?: AdminLogWhereUniqueInput | AdminLogWhereUniqueInput[]
|
|
update?: AdminLogUpdateWithWhereUniqueWithoutAdminInput | AdminLogUpdateWithWhereUniqueWithoutAdminInput[]
|
|
updateMany?: AdminLogUpdateManyWithWhereWithoutAdminInput | AdminLogUpdateManyWithWhereWithoutAdminInput[]
|
|
deleteMany?: AdminLogScalarWhereInput | AdminLogScalarWhereInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyWithoutCreatedByNestedInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCreatedByInput, ChanceTransactionUncheckedCreateWithoutCreatedByInput> | ChanceTransactionCreateWithoutCreatedByInput[] | ChanceTransactionUncheckedCreateWithoutCreatedByInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCreatedByInput | ChanceTransactionCreateOrConnectWithoutCreatedByInput[]
|
|
upsert?: ChanceTransactionUpsertWithWhereUniqueWithoutCreatedByInput | ChanceTransactionUpsertWithWhereUniqueWithoutCreatedByInput[]
|
|
createMany?: ChanceTransactionCreateManyCreatedByInputEnvelope
|
|
set?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
disconnect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
delete?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
update?: ChanceTransactionUpdateWithWhereUniqueWithoutCreatedByInput | ChanceTransactionUpdateWithWhereUniqueWithoutCreatedByInput[]
|
|
updateMany?: ChanceTransactionUpdateManyWithWhereWithoutCreatedByInput | ChanceTransactionUpdateManyWithWhereWithoutCreatedByInput[]
|
|
deleteMany?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCampaignCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<UserCampaignCreateWithoutUserInput, UserCampaignUncheckedCreateWithoutUserInput> | UserCampaignCreateWithoutUserInput[] | UserCampaignUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutUserInput | UserCampaignCreateOrConnectWithoutUserInput[]
|
|
createMany?: UserCampaignCreateManyUserInputEnvelope
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
}
|
|
|
|
export type ChanceTransactionCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutUserInput, ChanceTransactionUncheckedCreateWithoutUserInput> | ChanceTransactionCreateWithoutUserInput[] | ChanceTransactionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutUserInput | ChanceTransactionCreateOrConnectWithoutUserInput[]
|
|
createMany?: ChanceTransactionCreateManyUserInputEnvelope
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
}
|
|
|
|
export type SpinCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<SpinCreateWithoutUserInput, SpinUncheckedCreateWithoutUserInput> | SpinCreateWithoutUserInput[] | SpinUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutUserInput | SpinCreateOrConnectWithoutUserInput[]
|
|
createMany?: SpinCreateManyUserInputEnvelope
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserPrizeCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<UserPrizeCreateWithoutUserInput, UserPrizeUncheckedCreateWithoutUserInput> | UserPrizeCreateWithoutUserInput[] | UserPrizeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutUserInput | UserPrizeCreateOrConnectWithoutUserInput[]
|
|
createMany?: UserPrizeCreateManyUserInputEnvelope
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type OtpCodeCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<OtpCodeCreateWithoutUserInput, OtpCodeUncheckedCreateWithoutUserInput> | OtpCodeCreateWithoutUserInput[] | OtpCodeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: OtpCodeCreateOrConnectWithoutUserInput | OtpCodeCreateOrConnectWithoutUserInput[]
|
|
createMany?: OtpCodeCreateManyUserInputEnvelope
|
|
connect?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
}
|
|
|
|
export type SmsLogCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<SmsLogCreateWithoutUserInput, SmsLogUncheckedCreateWithoutUserInput> | SmsLogCreateWithoutUserInput[] | SmsLogUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SmsLogCreateOrConnectWithoutUserInput | SmsLogCreateOrConnectWithoutUserInput[]
|
|
createMany?: SmsLogCreateManyUserInputEnvelope
|
|
connect?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserCampaignUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<UserCampaignCreateWithoutUserInput, UserCampaignUncheckedCreateWithoutUserInput> | UserCampaignCreateWithoutUserInput[] | UserCampaignUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutUserInput | UserCampaignCreateOrConnectWithoutUserInput[]
|
|
createMany?: UserCampaignCreateManyUserInputEnvelope
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutUserInput, ChanceTransactionUncheckedCreateWithoutUserInput> | ChanceTransactionCreateWithoutUserInput[] | ChanceTransactionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutUserInput | ChanceTransactionCreateOrConnectWithoutUserInput[]
|
|
createMany?: ChanceTransactionCreateManyUserInputEnvelope
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
}
|
|
|
|
export type SpinUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<SpinCreateWithoutUserInput, SpinUncheckedCreateWithoutUserInput> | SpinCreateWithoutUserInput[] | SpinUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutUserInput | SpinCreateOrConnectWithoutUserInput[]
|
|
createMany?: SpinCreateManyUserInputEnvelope
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<UserPrizeCreateWithoutUserInput, UserPrizeUncheckedCreateWithoutUserInput> | UserPrizeCreateWithoutUserInput[] | UserPrizeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutUserInput | UserPrizeCreateOrConnectWithoutUserInput[]
|
|
createMany?: UserPrizeCreateManyUserInputEnvelope
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type OtpCodeUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<OtpCodeCreateWithoutUserInput, OtpCodeUncheckedCreateWithoutUserInput> | OtpCodeCreateWithoutUserInput[] | OtpCodeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: OtpCodeCreateOrConnectWithoutUserInput | OtpCodeCreateOrConnectWithoutUserInput[]
|
|
createMany?: OtpCodeCreateManyUserInputEnvelope
|
|
connect?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
}
|
|
|
|
export type SmsLogUncheckedCreateNestedManyWithoutUserInput = {
|
|
create?: XOR<SmsLogCreateWithoutUserInput, SmsLogUncheckedCreateWithoutUserInput> | SmsLogCreateWithoutUserInput[] | SmsLogUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SmsLogCreateOrConnectWithoutUserInput | SmsLogCreateOrConnectWithoutUserInput[]
|
|
createMany?: SmsLogCreateManyUserInputEnvelope
|
|
connect?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
}
|
|
|
|
export type NullableStringFieldUpdateOperationsInput = {
|
|
set?: string | null
|
|
}
|
|
|
|
export type EnumUserStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.UserStatus
|
|
}
|
|
|
|
export type NullableDateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string | null
|
|
}
|
|
|
|
export type UserCampaignUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<UserCampaignCreateWithoutUserInput, UserCampaignUncheckedCreateWithoutUserInput> | UserCampaignCreateWithoutUserInput[] | UserCampaignUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutUserInput | UserCampaignCreateOrConnectWithoutUserInput[]
|
|
upsert?: UserCampaignUpsertWithWhereUniqueWithoutUserInput | UserCampaignUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: UserCampaignCreateManyUserInputEnvelope
|
|
set?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
disconnect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
delete?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
update?: UserCampaignUpdateWithWhereUniqueWithoutUserInput | UserCampaignUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: UserCampaignUpdateManyWithWhereWithoutUserInput | UserCampaignUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: UserCampaignScalarWhereInput | UserCampaignScalarWhereInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutUserInput, ChanceTransactionUncheckedCreateWithoutUserInput> | ChanceTransactionCreateWithoutUserInput[] | ChanceTransactionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutUserInput | ChanceTransactionCreateOrConnectWithoutUserInput[]
|
|
upsert?: ChanceTransactionUpsertWithWhereUniqueWithoutUserInput | ChanceTransactionUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: ChanceTransactionCreateManyUserInputEnvelope
|
|
set?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
disconnect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
delete?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
update?: ChanceTransactionUpdateWithWhereUniqueWithoutUserInput | ChanceTransactionUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: ChanceTransactionUpdateManyWithWhereWithoutUserInput | ChanceTransactionUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
}
|
|
|
|
export type SpinUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<SpinCreateWithoutUserInput, SpinUncheckedCreateWithoutUserInput> | SpinCreateWithoutUserInput[] | SpinUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutUserInput | SpinCreateOrConnectWithoutUserInput[]
|
|
upsert?: SpinUpsertWithWhereUniqueWithoutUserInput | SpinUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: SpinCreateManyUserInputEnvelope
|
|
set?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
disconnect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
delete?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
update?: SpinUpdateWithWhereUniqueWithoutUserInput | SpinUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: SpinUpdateManyWithWhereWithoutUserInput | SpinUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
}
|
|
|
|
export type UserPrizeUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutUserInput, UserPrizeUncheckedCreateWithoutUserInput> | UserPrizeCreateWithoutUserInput[] | UserPrizeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutUserInput | UserPrizeCreateOrConnectWithoutUserInput[]
|
|
upsert?: UserPrizeUpsertWithWhereUniqueWithoutUserInput | UserPrizeUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: UserPrizeCreateManyUserInputEnvelope
|
|
set?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
disconnect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
delete?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
update?: UserPrizeUpdateWithWhereUniqueWithoutUserInput | UserPrizeUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: UserPrizeUpdateManyWithWhereWithoutUserInput | UserPrizeUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type OtpCodeUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<OtpCodeCreateWithoutUserInput, OtpCodeUncheckedCreateWithoutUserInput> | OtpCodeCreateWithoutUserInput[] | OtpCodeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: OtpCodeCreateOrConnectWithoutUserInput | OtpCodeCreateOrConnectWithoutUserInput[]
|
|
upsert?: OtpCodeUpsertWithWhereUniqueWithoutUserInput | OtpCodeUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: OtpCodeCreateManyUserInputEnvelope
|
|
set?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
disconnect?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
delete?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
connect?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
update?: OtpCodeUpdateWithWhereUniqueWithoutUserInput | OtpCodeUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: OtpCodeUpdateManyWithWhereWithoutUserInput | OtpCodeUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: OtpCodeScalarWhereInput | OtpCodeScalarWhereInput[]
|
|
}
|
|
|
|
export type SmsLogUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<SmsLogCreateWithoutUserInput, SmsLogUncheckedCreateWithoutUserInput> | SmsLogCreateWithoutUserInput[] | SmsLogUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SmsLogCreateOrConnectWithoutUserInput | SmsLogCreateOrConnectWithoutUserInput[]
|
|
upsert?: SmsLogUpsertWithWhereUniqueWithoutUserInput | SmsLogUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: SmsLogCreateManyUserInputEnvelope
|
|
set?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
disconnect?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
delete?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
connect?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
update?: SmsLogUpdateWithWhereUniqueWithoutUserInput | SmsLogUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: SmsLogUpdateManyWithWhereWithoutUserInput | SmsLogUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: SmsLogScalarWhereInput | SmsLogScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<UserCampaignCreateWithoutUserInput, UserCampaignUncheckedCreateWithoutUserInput> | UserCampaignCreateWithoutUserInput[] | UserCampaignUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutUserInput | UserCampaignCreateOrConnectWithoutUserInput[]
|
|
upsert?: UserCampaignUpsertWithWhereUniqueWithoutUserInput | UserCampaignUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: UserCampaignCreateManyUserInputEnvelope
|
|
set?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
disconnect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
delete?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
update?: UserCampaignUpdateWithWhereUniqueWithoutUserInput | UserCampaignUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: UserCampaignUpdateManyWithWhereWithoutUserInput | UserCampaignUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: UserCampaignScalarWhereInput | UserCampaignScalarWhereInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutUserInput, ChanceTransactionUncheckedCreateWithoutUserInput> | ChanceTransactionCreateWithoutUserInput[] | ChanceTransactionUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutUserInput | ChanceTransactionCreateOrConnectWithoutUserInput[]
|
|
upsert?: ChanceTransactionUpsertWithWhereUniqueWithoutUserInput | ChanceTransactionUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: ChanceTransactionCreateManyUserInputEnvelope
|
|
set?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
disconnect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
delete?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
update?: ChanceTransactionUpdateWithWhereUniqueWithoutUserInput | ChanceTransactionUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: ChanceTransactionUpdateManyWithWhereWithoutUserInput | ChanceTransactionUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<SpinCreateWithoutUserInput, SpinUncheckedCreateWithoutUserInput> | SpinCreateWithoutUserInput[] | SpinUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutUserInput | SpinCreateOrConnectWithoutUserInput[]
|
|
upsert?: SpinUpsertWithWhereUniqueWithoutUserInput | SpinUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: SpinCreateManyUserInputEnvelope
|
|
set?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
disconnect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
delete?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
update?: SpinUpdateWithWhereUniqueWithoutUserInput | SpinUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: SpinUpdateManyWithWhereWithoutUserInput | SpinUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutUserInput, UserPrizeUncheckedCreateWithoutUserInput> | UserPrizeCreateWithoutUserInput[] | UserPrizeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutUserInput | UserPrizeCreateOrConnectWithoutUserInput[]
|
|
upsert?: UserPrizeUpsertWithWhereUniqueWithoutUserInput | UserPrizeUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: UserPrizeCreateManyUserInputEnvelope
|
|
set?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
disconnect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
delete?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
update?: UserPrizeUpdateWithWhereUniqueWithoutUserInput | UserPrizeUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: UserPrizeUpdateManyWithWhereWithoutUserInput | UserPrizeUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type OtpCodeUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<OtpCodeCreateWithoutUserInput, OtpCodeUncheckedCreateWithoutUserInput> | OtpCodeCreateWithoutUserInput[] | OtpCodeUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: OtpCodeCreateOrConnectWithoutUserInput | OtpCodeCreateOrConnectWithoutUserInput[]
|
|
upsert?: OtpCodeUpsertWithWhereUniqueWithoutUserInput | OtpCodeUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: OtpCodeCreateManyUserInputEnvelope
|
|
set?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
disconnect?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
delete?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
connect?: OtpCodeWhereUniqueInput | OtpCodeWhereUniqueInput[]
|
|
update?: OtpCodeUpdateWithWhereUniqueWithoutUserInput | OtpCodeUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: OtpCodeUpdateManyWithWhereWithoutUserInput | OtpCodeUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: OtpCodeScalarWhereInput | OtpCodeScalarWhereInput[]
|
|
}
|
|
|
|
export type SmsLogUncheckedUpdateManyWithoutUserNestedInput = {
|
|
create?: XOR<SmsLogCreateWithoutUserInput, SmsLogUncheckedCreateWithoutUserInput> | SmsLogCreateWithoutUserInput[] | SmsLogUncheckedCreateWithoutUserInput[]
|
|
connectOrCreate?: SmsLogCreateOrConnectWithoutUserInput | SmsLogCreateOrConnectWithoutUserInput[]
|
|
upsert?: SmsLogUpsertWithWhereUniqueWithoutUserInput | SmsLogUpsertWithWhereUniqueWithoutUserInput[]
|
|
createMany?: SmsLogCreateManyUserInputEnvelope
|
|
set?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
disconnect?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
delete?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
connect?: SmsLogWhereUniqueInput | SmsLogWhereUniqueInput[]
|
|
update?: SmsLogUpdateWithWhereUniqueWithoutUserInput | SmsLogUpdateWithWhereUniqueWithoutUserInput[]
|
|
updateMany?: SmsLogUpdateManyWithWhereWithoutUserInput | SmsLogUpdateManyWithWhereWithoutUserInput[]
|
|
deleteMany?: SmsLogScalarWhereInput | SmsLogScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutOtpCodesInput = {
|
|
create?: XOR<UserCreateWithoutOtpCodesInput, UserUncheckedCreateWithoutOtpCodesInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutOtpCodesInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type IntFieldUpdateOperationsInput = {
|
|
set?: number
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type BoolFieldUpdateOperationsInput = {
|
|
set?: boolean
|
|
}
|
|
|
|
export type UserUpdateOneWithoutOtpCodesNestedInput = {
|
|
create?: XOR<UserCreateWithoutOtpCodesInput, UserUncheckedCreateWithoutOtpCodesInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutOtpCodesInput
|
|
upsert?: UserUpsertWithoutOtpCodesInput
|
|
disconnect?: UserWhereInput | boolean
|
|
delete?: UserWhereInput | boolean
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutOtpCodesInput, UserUpdateWithoutOtpCodesInput>, UserUncheckedUpdateWithoutOtpCodesInput>
|
|
}
|
|
|
|
export type PrizeCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<PrizeCreateWithoutCampaignInput, PrizeUncheckedCreateWithoutCampaignInput> | PrizeCreateWithoutCampaignInput[] | PrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutCampaignInput | PrizeCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: PrizeCreateManyCampaignInputEnvelope
|
|
connect?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserCampaignCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<UserCampaignCreateWithoutCampaignInput, UserCampaignUncheckedCreateWithoutCampaignInput> | UserCampaignCreateWithoutCampaignInput[] | UserCampaignUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutCampaignInput | UserCampaignCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: UserCampaignCreateManyCampaignInputEnvelope
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
}
|
|
|
|
export type ChanceTransactionCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCampaignInput, ChanceTransactionUncheckedCreateWithoutCampaignInput> | ChanceTransactionCreateWithoutCampaignInput[] | ChanceTransactionUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCampaignInput | ChanceTransactionCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: ChanceTransactionCreateManyCampaignInputEnvelope
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
}
|
|
|
|
export type SpinCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<SpinCreateWithoutCampaignInput, SpinUncheckedCreateWithoutCampaignInput> | SpinCreateWithoutCampaignInput[] | SpinUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutCampaignInput | SpinCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: SpinCreateManyCampaignInputEnvelope
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserPrizeCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<UserPrizeCreateWithoutCampaignInput, UserPrizeUncheckedCreateWithoutCampaignInput> | UserPrizeCreateWithoutCampaignInput[] | UserPrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutCampaignInput | UserPrizeCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: UserPrizeCreateManyCampaignInputEnvelope
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type PrizeUncheckedCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<PrizeCreateWithoutCampaignInput, PrizeUncheckedCreateWithoutCampaignInput> | PrizeCreateWithoutCampaignInput[] | PrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutCampaignInput | PrizeCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: PrizeCreateManyCampaignInputEnvelope
|
|
connect?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserCampaignUncheckedCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<UserCampaignCreateWithoutCampaignInput, UserCampaignUncheckedCreateWithoutCampaignInput> | UserCampaignCreateWithoutCampaignInput[] | UserCampaignUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutCampaignInput | UserCampaignCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: UserCampaignCreateManyCampaignInputEnvelope
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCampaignInput, ChanceTransactionUncheckedCreateWithoutCampaignInput> | ChanceTransactionCreateWithoutCampaignInput[] | ChanceTransactionUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCampaignInput | ChanceTransactionCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: ChanceTransactionCreateManyCampaignInputEnvelope
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
}
|
|
|
|
export type SpinUncheckedCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<SpinCreateWithoutCampaignInput, SpinUncheckedCreateWithoutCampaignInput> | SpinCreateWithoutCampaignInput[] | SpinUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutCampaignInput | SpinCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: SpinCreateManyCampaignInputEnvelope
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateNestedManyWithoutCampaignInput = {
|
|
create?: XOR<UserPrizeCreateWithoutCampaignInput, UserPrizeUncheckedCreateWithoutCampaignInput> | UserPrizeCreateWithoutCampaignInput[] | UserPrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutCampaignInput | UserPrizeCreateOrConnectWithoutCampaignInput[]
|
|
createMany?: UserPrizeCreateManyCampaignInputEnvelope
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnumCampaignStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.CampaignStatus
|
|
}
|
|
|
|
export type EnumWheelDesignFieldUpdateOperationsInput = {
|
|
set?: $Enums.WheelDesign
|
|
}
|
|
|
|
export type PrizeUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<PrizeCreateWithoutCampaignInput, PrizeUncheckedCreateWithoutCampaignInput> | PrizeCreateWithoutCampaignInput[] | PrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutCampaignInput | PrizeCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: PrizeUpsertWithWhereUniqueWithoutCampaignInput | PrizeUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: PrizeCreateManyCampaignInputEnvelope
|
|
set?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
disconnect?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
delete?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
connect?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
update?: PrizeUpdateWithWhereUniqueWithoutCampaignInput | PrizeUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: PrizeUpdateManyWithWhereWithoutCampaignInput | PrizeUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: PrizeScalarWhereInput | PrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCampaignUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<UserCampaignCreateWithoutCampaignInput, UserCampaignUncheckedCreateWithoutCampaignInput> | UserCampaignCreateWithoutCampaignInput[] | UserCampaignUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutCampaignInput | UserCampaignCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: UserCampaignUpsertWithWhereUniqueWithoutCampaignInput | UserCampaignUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: UserCampaignCreateManyCampaignInputEnvelope
|
|
set?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
disconnect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
delete?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
update?: UserCampaignUpdateWithWhereUniqueWithoutCampaignInput | UserCampaignUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: UserCampaignUpdateManyWithWhereWithoutCampaignInput | UserCampaignUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: UserCampaignScalarWhereInput | UserCampaignScalarWhereInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCampaignInput, ChanceTransactionUncheckedCreateWithoutCampaignInput> | ChanceTransactionCreateWithoutCampaignInput[] | ChanceTransactionUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCampaignInput | ChanceTransactionCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: ChanceTransactionUpsertWithWhereUniqueWithoutCampaignInput | ChanceTransactionUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: ChanceTransactionCreateManyCampaignInputEnvelope
|
|
set?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
disconnect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
delete?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
update?: ChanceTransactionUpdateWithWhereUniqueWithoutCampaignInput | ChanceTransactionUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: ChanceTransactionUpdateManyWithWhereWithoutCampaignInput | ChanceTransactionUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
}
|
|
|
|
export type SpinUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<SpinCreateWithoutCampaignInput, SpinUncheckedCreateWithoutCampaignInput> | SpinCreateWithoutCampaignInput[] | SpinUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutCampaignInput | SpinCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: SpinUpsertWithWhereUniqueWithoutCampaignInput | SpinUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: SpinCreateManyCampaignInputEnvelope
|
|
set?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
disconnect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
delete?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
update?: SpinUpdateWithWhereUniqueWithoutCampaignInput | SpinUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: SpinUpdateManyWithWhereWithoutCampaignInput | SpinUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
}
|
|
|
|
export type UserPrizeUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutCampaignInput, UserPrizeUncheckedCreateWithoutCampaignInput> | UserPrizeCreateWithoutCampaignInput[] | UserPrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutCampaignInput | UserPrizeCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: UserPrizeUpsertWithWhereUniqueWithoutCampaignInput | UserPrizeUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: UserPrizeCreateManyCampaignInputEnvelope
|
|
set?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
disconnect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
delete?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
update?: UserPrizeUpdateWithWhereUniqueWithoutCampaignInput | UserPrizeUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: UserPrizeUpdateManyWithWhereWithoutCampaignInput | UserPrizeUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<PrizeCreateWithoutCampaignInput, PrizeUncheckedCreateWithoutCampaignInput> | PrizeCreateWithoutCampaignInput[] | PrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutCampaignInput | PrizeCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: PrizeUpsertWithWhereUniqueWithoutCampaignInput | PrizeUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: PrizeCreateManyCampaignInputEnvelope
|
|
set?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
disconnect?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
delete?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
connect?: PrizeWhereUniqueInput | PrizeWhereUniqueInput[]
|
|
update?: PrizeUpdateWithWhereUniqueWithoutCampaignInput | PrizeUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: PrizeUpdateManyWithWhereWithoutCampaignInput | PrizeUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: PrizeScalarWhereInput | PrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<UserCampaignCreateWithoutCampaignInput, UserCampaignUncheckedCreateWithoutCampaignInput> | UserCampaignCreateWithoutCampaignInput[] | UserCampaignUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserCampaignCreateOrConnectWithoutCampaignInput | UserCampaignCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: UserCampaignUpsertWithWhereUniqueWithoutCampaignInput | UserCampaignUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: UserCampaignCreateManyCampaignInputEnvelope
|
|
set?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
disconnect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
delete?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
connect?: UserCampaignWhereUniqueInput | UserCampaignWhereUniqueInput[]
|
|
update?: UserCampaignUpdateWithWhereUniqueWithoutCampaignInput | UserCampaignUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: UserCampaignUpdateManyWithWhereWithoutCampaignInput | UserCampaignUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: UserCampaignScalarWhereInput | UserCampaignScalarWhereInput[]
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<ChanceTransactionCreateWithoutCampaignInput, ChanceTransactionUncheckedCreateWithoutCampaignInput> | ChanceTransactionCreateWithoutCampaignInput[] | ChanceTransactionUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: ChanceTransactionCreateOrConnectWithoutCampaignInput | ChanceTransactionCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: ChanceTransactionUpsertWithWhereUniqueWithoutCampaignInput | ChanceTransactionUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: ChanceTransactionCreateManyCampaignInputEnvelope
|
|
set?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
disconnect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
delete?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
connect?: ChanceTransactionWhereUniqueInput | ChanceTransactionWhereUniqueInput[]
|
|
update?: ChanceTransactionUpdateWithWhereUniqueWithoutCampaignInput | ChanceTransactionUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: ChanceTransactionUpdateManyWithWhereWithoutCampaignInput | ChanceTransactionUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<SpinCreateWithoutCampaignInput, SpinUncheckedCreateWithoutCampaignInput> | SpinCreateWithoutCampaignInput[] | SpinUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutCampaignInput | SpinCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: SpinUpsertWithWhereUniqueWithoutCampaignInput | SpinUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: SpinCreateManyCampaignInputEnvelope
|
|
set?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
disconnect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
delete?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
update?: SpinUpdateWithWhereUniqueWithoutCampaignInput | SpinUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: SpinUpdateManyWithWhereWithoutCampaignInput | SpinUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyWithoutCampaignNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutCampaignInput, UserPrizeUncheckedCreateWithoutCampaignInput> | UserPrizeCreateWithoutCampaignInput[] | UserPrizeUncheckedCreateWithoutCampaignInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutCampaignInput | UserPrizeCreateOrConnectWithoutCampaignInput[]
|
|
upsert?: UserPrizeUpsertWithWhereUniqueWithoutCampaignInput | UserPrizeUpsertWithWhereUniqueWithoutCampaignInput[]
|
|
createMany?: UserPrizeCreateManyCampaignInputEnvelope
|
|
set?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
disconnect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
delete?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
update?: UserPrizeUpdateWithWhereUniqueWithoutCampaignInput | UserPrizeUpdateWithWhereUniqueWithoutCampaignInput[]
|
|
updateMany?: UserPrizeUpdateManyWithWhereWithoutCampaignInput | UserPrizeUpdateManyWithWhereWithoutCampaignInput[]
|
|
deleteMany?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type CampaignCreateNestedOneWithoutPrizesInput = {
|
|
create?: XOR<CampaignCreateWithoutPrizesInput, CampaignUncheckedCreateWithoutPrizesInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutPrizesInput
|
|
connect?: CampaignWhereUniqueInput
|
|
}
|
|
|
|
export type SpinCreateNestedManyWithoutPrizeInput = {
|
|
create?: XOR<SpinCreateWithoutPrizeInput, SpinUncheckedCreateWithoutPrizeInput> | SpinCreateWithoutPrizeInput[] | SpinUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutPrizeInput | SpinCreateOrConnectWithoutPrizeInput[]
|
|
createMany?: SpinCreateManyPrizeInputEnvelope
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserPrizeCreateNestedManyWithoutPrizeInput = {
|
|
create?: XOR<UserPrizeCreateWithoutPrizeInput, UserPrizeUncheckedCreateWithoutPrizeInput> | UserPrizeCreateWithoutPrizeInput[] | UserPrizeUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutPrizeInput | UserPrizeCreateOrConnectWithoutPrizeInput[]
|
|
createMany?: UserPrizeCreateManyPrizeInputEnvelope
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type SpinUncheckedCreateNestedManyWithoutPrizeInput = {
|
|
create?: XOR<SpinCreateWithoutPrizeInput, SpinUncheckedCreateWithoutPrizeInput> | SpinCreateWithoutPrizeInput[] | SpinUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutPrizeInput | SpinCreateOrConnectWithoutPrizeInput[]
|
|
createMany?: SpinCreateManyPrizeInputEnvelope
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateNestedManyWithoutPrizeInput = {
|
|
create?: XOR<UserPrizeCreateWithoutPrizeInput, UserPrizeUncheckedCreateWithoutPrizeInput> | UserPrizeCreateWithoutPrizeInput[] | UserPrizeUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutPrizeInput | UserPrizeCreateOrConnectWithoutPrizeInput[]
|
|
createMany?: UserPrizeCreateManyPrizeInputEnvelope
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
}
|
|
|
|
export type EnumPrizeTypeFieldUpdateOperationsInput = {
|
|
set?: $Enums.PrizeType
|
|
}
|
|
|
|
export type EnumStockTypeFieldUpdateOperationsInput = {
|
|
set?: $Enums.StockType
|
|
}
|
|
|
|
export type NullableIntFieldUpdateOperationsInput = {
|
|
set?: number | null
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type EnumPrizeStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.PrizeStatus
|
|
}
|
|
|
|
export type CampaignUpdateOneRequiredWithoutPrizesNestedInput = {
|
|
create?: XOR<CampaignCreateWithoutPrizesInput, CampaignUncheckedCreateWithoutPrizesInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutPrizesInput
|
|
upsert?: CampaignUpsertWithoutPrizesInput
|
|
connect?: CampaignWhereUniqueInput
|
|
update?: XOR<XOR<CampaignUpdateToOneWithWhereWithoutPrizesInput, CampaignUpdateWithoutPrizesInput>, CampaignUncheckedUpdateWithoutPrizesInput>
|
|
}
|
|
|
|
export type SpinUpdateManyWithoutPrizeNestedInput = {
|
|
create?: XOR<SpinCreateWithoutPrizeInput, SpinUncheckedCreateWithoutPrizeInput> | SpinCreateWithoutPrizeInput[] | SpinUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutPrizeInput | SpinCreateOrConnectWithoutPrizeInput[]
|
|
upsert?: SpinUpsertWithWhereUniqueWithoutPrizeInput | SpinUpsertWithWhereUniqueWithoutPrizeInput[]
|
|
createMany?: SpinCreateManyPrizeInputEnvelope
|
|
set?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
disconnect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
delete?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
update?: SpinUpdateWithWhereUniqueWithoutPrizeInput | SpinUpdateWithWhereUniqueWithoutPrizeInput[]
|
|
updateMany?: SpinUpdateManyWithWhereWithoutPrizeInput | SpinUpdateManyWithWhereWithoutPrizeInput[]
|
|
deleteMany?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
}
|
|
|
|
export type UserPrizeUpdateManyWithoutPrizeNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutPrizeInput, UserPrizeUncheckedCreateWithoutPrizeInput> | UserPrizeCreateWithoutPrizeInput[] | UserPrizeUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutPrizeInput | UserPrizeCreateOrConnectWithoutPrizeInput[]
|
|
upsert?: UserPrizeUpsertWithWhereUniqueWithoutPrizeInput | UserPrizeUpsertWithWhereUniqueWithoutPrizeInput[]
|
|
createMany?: UserPrizeCreateManyPrizeInputEnvelope
|
|
set?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
disconnect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
delete?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
update?: UserPrizeUpdateWithWhereUniqueWithoutPrizeInput | UserPrizeUpdateWithWhereUniqueWithoutPrizeInput[]
|
|
updateMany?: UserPrizeUpdateManyWithWhereWithoutPrizeInput | UserPrizeUpdateManyWithWhereWithoutPrizeInput[]
|
|
deleteMany?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyWithoutPrizeNestedInput = {
|
|
create?: XOR<SpinCreateWithoutPrizeInput, SpinUncheckedCreateWithoutPrizeInput> | SpinCreateWithoutPrizeInput[] | SpinUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: SpinCreateOrConnectWithoutPrizeInput | SpinCreateOrConnectWithoutPrizeInput[]
|
|
upsert?: SpinUpsertWithWhereUniqueWithoutPrizeInput | SpinUpsertWithWhereUniqueWithoutPrizeInput[]
|
|
createMany?: SpinCreateManyPrizeInputEnvelope
|
|
set?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
disconnect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
delete?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
connect?: SpinWhereUniqueInput | SpinWhereUniqueInput[]
|
|
update?: SpinUpdateWithWhereUniqueWithoutPrizeInput | SpinUpdateWithWhereUniqueWithoutPrizeInput[]
|
|
updateMany?: SpinUpdateManyWithWhereWithoutPrizeInput | SpinUpdateManyWithWhereWithoutPrizeInput[]
|
|
deleteMany?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyWithoutPrizeNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutPrizeInput, UserPrizeUncheckedCreateWithoutPrizeInput> | UserPrizeCreateWithoutPrizeInput[] | UserPrizeUncheckedCreateWithoutPrizeInput[]
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutPrizeInput | UserPrizeCreateOrConnectWithoutPrizeInput[]
|
|
upsert?: UserPrizeUpsertWithWhereUniqueWithoutPrizeInput | UserPrizeUpsertWithWhereUniqueWithoutPrizeInput[]
|
|
createMany?: UserPrizeCreateManyPrizeInputEnvelope
|
|
set?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
disconnect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
delete?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
connect?: UserPrizeWhereUniqueInput | UserPrizeWhereUniqueInput[]
|
|
update?: UserPrizeUpdateWithWhereUniqueWithoutPrizeInput | UserPrizeUpdateWithWhereUniqueWithoutPrizeInput[]
|
|
updateMany?: UserPrizeUpdateManyWithWhereWithoutPrizeInput | UserPrizeUpdateManyWithWhereWithoutPrizeInput[]
|
|
deleteMany?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutUserCampaignsInput = {
|
|
create?: XOR<UserCreateWithoutUserCampaignsInput, UserUncheckedCreateWithoutUserCampaignsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutUserCampaignsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type CampaignCreateNestedOneWithoutUserCampaignsInput = {
|
|
create?: XOR<CampaignCreateWithoutUserCampaignsInput, CampaignUncheckedCreateWithoutUserCampaignsInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutUserCampaignsInput
|
|
connect?: CampaignWhereUniqueInput
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutUserCampaignsNestedInput = {
|
|
create?: XOR<UserCreateWithoutUserCampaignsInput, UserUncheckedCreateWithoutUserCampaignsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutUserCampaignsInput
|
|
upsert?: UserUpsertWithoutUserCampaignsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutUserCampaignsInput, UserUpdateWithoutUserCampaignsInput>, UserUncheckedUpdateWithoutUserCampaignsInput>
|
|
}
|
|
|
|
export type CampaignUpdateOneRequiredWithoutUserCampaignsNestedInput = {
|
|
create?: XOR<CampaignCreateWithoutUserCampaignsInput, CampaignUncheckedCreateWithoutUserCampaignsInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutUserCampaignsInput
|
|
upsert?: CampaignUpsertWithoutUserCampaignsInput
|
|
connect?: CampaignWhereUniqueInput
|
|
update?: XOR<XOR<CampaignUpdateToOneWithWhereWithoutUserCampaignsInput, CampaignUpdateWithoutUserCampaignsInput>, CampaignUncheckedUpdateWithoutUserCampaignsInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutChanceTransactionsInput = {
|
|
create?: XOR<UserCreateWithoutChanceTransactionsInput, UserUncheckedCreateWithoutChanceTransactionsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutChanceTransactionsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type CampaignCreateNestedOneWithoutChanceTxnsInput = {
|
|
create?: XOR<CampaignCreateWithoutChanceTxnsInput, CampaignUncheckedCreateWithoutChanceTxnsInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutChanceTxnsInput
|
|
connect?: CampaignWhereUniqueInput
|
|
}
|
|
|
|
export type AdminCreateNestedOneWithoutChanceTxnsInput = {
|
|
create?: XOR<AdminCreateWithoutChanceTxnsInput, AdminUncheckedCreateWithoutChanceTxnsInput>
|
|
connectOrCreate?: AdminCreateOrConnectWithoutChanceTxnsInput
|
|
connect?: AdminWhereUniqueInput
|
|
}
|
|
|
|
export type EnumChanceTxnTypeFieldUpdateOperationsInput = {
|
|
set?: $Enums.ChanceTxnType
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutChanceTransactionsNestedInput = {
|
|
create?: XOR<UserCreateWithoutChanceTransactionsInput, UserUncheckedCreateWithoutChanceTransactionsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutChanceTransactionsInput
|
|
upsert?: UserUpsertWithoutChanceTransactionsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutChanceTransactionsInput, UserUpdateWithoutChanceTransactionsInput>, UserUncheckedUpdateWithoutChanceTransactionsInput>
|
|
}
|
|
|
|
export type CampaignUpdateOneRequiredWithoutChanceTxnsNestedInput = {
|
|
create?: XOR<CampaignCreateWithoutChanceTxnsInput, CampaignUncheckedCreateWithoutChanceTxnsInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutChanceTxnsInput
|
|
upsert?: CampaignUpsertWithoutChanceTxnsInput
|
|
connect?: CampaignWhereUniqueInput
|
|
update?: XOR<XOR<CampaignUpdateToOneWithWhereWithoutChanceTxnsInput, CampaignUpdateWithoutChanceTxnsInput>, CampaignUncheckedUpdateWithoutChanceTxnsInput>
|
|
}
|
|
|
|
export type AdminUpdateOneWithoutChanceTxnsNestedInput = {
|
|
create?: XOR<AdminCreateWithoutChanceTxnsInput, AdminUncheckedCreateWithoutChanceTxnsInput>
|
|
connectOrCreate?: AdminCreateOrConnectWithoutChanceTxnsInput
|
|
upsert?: AdminUpsertWithoutChanceTxnsInput
|
|
disconnect?: AdminWhereInput | boolean
|
|
delete?: AdminWhereInput | boolean
|
|
connect?: AdminWhereUniqueInput
|
|
update?: XOR<XOR<AdminUpdateToOneWithWhereWithoutChanceTxnsInput, AdminUpdateWithoutChanceTxnsInput>, AdminUncheckedUpdateWithoutChanceTxnsInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutSpinsInput = {
|
|
create?: XOR<UserCreateWithoutSpinsInput, UserUncheckedCreateWithoutSpinsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutSpinsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type CampaignCreateNestedOneWithoutSpinsInput = {
|
|
create?: XOR<CampaignCreateWithoutSpinsInput, CampaignUncheckedCreateWithoutSpinsInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutSpinsInput
|
|
connect?: CampaignWhereUniqueInput
|
|
}
|
|
|
|
export type PrizeCreateNestedOneWithoutSpinsInput = {
|
|
create?: XOR<PrizeCreateWithoutSpinsInput, PrizeUncheckedCreateWithoutSpinsInput>
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutSpinsInput
|
|
connect?: PrizeWhereUniqueInput
|
|
}
|
|
|
|
export type UserPrizeCreateNestedOneWithoutSpinInput = {
|
|
create?: XOR<UserPrizeCreateWithoutSpinInput, UserPrizeUncheckedCreateWithoutSpinInput>
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutSpinInput
|
|
connect?: UserPrizeWhereUniqueInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateNestedOneWithoutSpinInput = {
|
|
create?: XOR<UserPrizeCreateWithoutSpinInput, UserPrizeUncheckedCreateWithoutSpinInput>
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutSpinInput
|
|
connect?: UserPrizeWhereUniqueInput
|
|
}
|
|
|
|
export type EnumSpinStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.SpinStatus
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutSpinsNestedInput = {
|
|
create?: XOR<UserCreateWithoutSpinsInput, UserUncheckedCreateWithoutSpinsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutSpinsInput
|
|
upsert?: UserUpsertWithoutSpinsInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSpinsInput, UserUpdateWithoutSpinsInput>, UserUncheckedUpdateWithoutSpinsInput>
|
|
}
|
|
|
|
export type CampaignUpdateOneRequiredWithoutSpinsNestedInput = {
|
|
create?: XOR<CampaignCreateWithoutSpinsInput, CampaignUncheckedCreateWithoutSpinsInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutSpinsInput
|
|
upsert?: CampaignUpsertWithoutSpinsInput
|
|
connect?: CampaignWhereUniqueInput
|
|
update?: XOR<XOR<CampaignUpdateToOneWithWhereWithoutSpinsInput, CampaignUpdateWithoutSpinsInput>, CampaignUncheckedUpdateWithoutSpinsInput>
|
|
}
|
|
|
|
export type PrizeUpdateOneWithoutSpinsNestedInput = {
|
|
create?: XOR<PrizeCreateWithoutSpinsInput, PrizeUncheckedCreateWithoutSpinsInput>
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutSpinsInput
|
|
upsert?: PrizeUpsertWithoutSpinsInput
|
|
disconnect?: PrizeWhereInput | boolean
|
|
delete?: PrizeWhereInput | boolean
|
|
connect?: PrizeWhereUniqueInput
|
|
update?: XOR<XOR<PrizeUpdateToOneWithWhereWithoutSpinsInput, PrizeUpdateWithoutSpinsInput>, PrizeUncheckedUpdateWithoutSpinsInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateOneWithoutSpinNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutSpinInput, UserPrizeUncheckedCreateWithoutSpinInput>
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutSpinInput
|
|
upsert?: UserPrizeUpsertWithoutSpinInput
|
|
disconnect?: UserPrizeWhereInput | boolean
|
|
delete?: UserPrizeWhereInput | boolean
|
|
connect?: UserPrizeWhereUniqueInput
|
|
update?: XOR<XOR<UserPrizeUpdateToOneWithWhereWithoutSpinInput, UserPrizeUpdateWithoutSpinInput>, UserPrizeUncheckedUpdateWithoutSpinInput>
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateOneWithoutSpinNestedInput = {
|
|
create?: XOR<UserPrizeCreateWithoutSpinInput, UserPrizeUncheckedCreateWithoutSpinInput>
|
|
connectOrCreate?: UserPrizeCreateOrConnectWithoutSpinInput
|
|
upsert?: UserPrizeUpsertWithoutSpinInput
|
|
disconnect?: UserPrizeWhereInput | boolean
|
|
delete?: UserPrizeWhereInput | boolean
|
|
connect?: UserPrizeWhereUniqueInput
|
|
update?: XOR<XOR<UserPrizeUpdateToOneWithWhereWithoutSpinInput, UserPrizeUpdateWithoutSpinInput>, UserPrizeUncheckedUpdateWithoutSpinInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutUserPrizesInput = {
|
|
create?: XOR<UserCreateWithoutUserPrizesInput, UserUncheckedCreateWithoutUserPrizesInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutUserPrizesInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type CampaignCreateNestedOneWithoutUserPrizesInput = {
|
|
create?: XOR<CampaignCreateWithoutUserPrizesInput, CampaignUncheckedCreateWithoutUserPrizesInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutUserPrizesInput
|
|
connect?: CampaignWhereUniqueInput
|
|
}
|
|
|
|
export type PrizeCreateNestedOneWithoutUserPrizesInput = {
|
|
create?: XOR<PrizeCreateWithoutUserPrizesInput, PrizeUncheckedCreateWithoutUserPrizesInput>
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutUserPrizesInput
|
|
connect?: PrizeWhereUniqueInput
|
|
}
|
|
|
|
export type SpinCreateNestedOneWithoutUserPrizeInput = {
|
|
create?: XOR<SpinCreateWithoutUserPrizeInput, SpinUncheckedCreateWithoutUserPrizeInput>
|
|
connectOrCreate?: SpinCreateOrConnectWithoutUserPrizeInput
|
|
connect?: SpinWhereUniqueInput
|
|
}
|
|
|
|
export type EnumUserPrizeStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.UserPrizeStatus
|
|
}
|
|
|
|
export type UserUpdateOneRequiredWithoutUserPrizesNestedInput = {
|
|
create?: XOR<UserCreateWithoutUserPrizesInput, UserUncheckedCreateWithoutUserPrizesInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutUserPrizesInput
|
|
upsert?: UserUpsertWithoutUserPrizesInput
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutUserPrizesInput, UserUpdateWithoutUserPrizesInput>, UserUncheckedUpdateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type CampaignUpdateOneRequiredWithoutUserPrizesNestedInput = {
|
|
create?: XOR<CampaignCreateWithoutUserPrizesInput, CampaignUncheckedCreateWithoutUserPrizesInput>
|
|
connectOrCreate?: CampaignCreateOrConnectWithoutUserPrizesInput
|
|
upsert?: CampaignUpsertWithoutUserPrizesInput
|
|
connect?: CampaignWhereUniqueInput
|
|
update?: XOR<XOR<CampaignUpdateToOneWithWhereWithoutUserPrizesInput, CampaignUpdateWithoutUserPrizesInput>, CampaignUncheckedUpdateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type PrizeUpdateOneRequiredWithoutUserPrizesNestedInput = {
|
|
create?: XOR<PrizeCreateWithoutUserPrizesInput, PrizeUncheckedCreateWithoutUserPrizesInput>
|
|
connectOrCreate?: PrizeCreateOrConnectWithoutUserPrizesInput
|
|
upsert?: PrizeUpsertWithoutUserPrizesInput
|
|
connect?: PrizeWhereUniqueInput
|
|
update?: XOR<XOR<PrizeUpdateToOneWithWhereWithoutUserPrizesInput, PrizeUpdateWithoutUserPrizesInput>, PrizeUncheckedUpdateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type SpinUpdateOneRequiredWithoutUserPrizeNestedInput = {
|
|
create?: XOR<SpinCreateWithoutUserPrizeInput, SpinUncheckedCreateWithoutUserPrizeInput>
|
|
connectOrCreate?: SpinCreateOrConnectWithoutUserPrizeInput
|
|
upsert?: SpinUpsertWithoutUserPrizeInput
|
|
connect?: SpinWhereUniqueInput
|
|
update?: XOR<XOR<SpinUpdateToOneWithWhereWithoutUserPrizeInput, SpinUpdateWithoutUserPrizeInput>, SpinUncheckedUpdateWithoutUserPrizeInput>
|
|
}
|
|
|
|
export type UserCreateNestedOneWithoutSmsLogsInput = {
|
|
create?: XOR<UserCreateWithoutSmsLogsInput, UserUncheckedCreateWithoutSmsLogsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutSmsLogsInput
|
|
connect?: UserWhereUniqueInput
|
|
}
|
|
|
|
export type EnumSmsTypeFieldUpdateOperationsInput = {
|
|
set?: $Enums.SmsType
|
|
}
|
|
|
|
export type EnumSmsStatusFieldUpdateOperationsInput = {
|
|
set?: $Enums.SmsStatus
|
|
}
|
|
|
|
export type UserUpdateOneWithoutSmsLogsNestedInput = {
|
|
create?: XOR<UserCreateWithoutSmsLogsInput, UserUncheckedCreateWithoutSmsLogsInput>
|
|
connectOrCreate?: UserCreateOrConnectWithoutSmsLogsInput
|
|
upsert?: UserUpsertWithoutSmsLogsInput
|
|
disconnect?: UserWhereInput | boolean
|
|
delete?: UserWhereInput | boolean
|
|
connect?: UserWhereUniqueInput
|
|
update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSmsLogsInput, UserUpdateWithoutSmsLogsInput>, UserUncheckedUpdateWithoutSmsLogsInput>
|
|
}
|
|
|
|
export type AdminCreateNestedOneWithoutAuditLogsInput = {
|
|
create?: XOR<AdminCreateWithoutAuditLogsInput, AdminUncheckedCreateWithoutAuditLogsInput>
|
|
connectOrCreate?: AdminCreateOrConnectWithoutAuditLogsInput
|
|
connect?: AdminWhereUniqueInput
|
|
}
|
|
|
|
export type AdminUpdateOneRequiredWithoutAuditLogsNestedInput = {
|
|
create?: XOR<AdminCreateWithoutAuditLogsInput, AdminUncheckedCreateWithoutAuditLogsInput>
|
|
connectOrCreate?: AdminCreateOrConnectWithoutAuditLogsInput
|
|
upsert?: AdminUpsertWithoutAuditLogsInput
|
|
connect?: AdminWhereUniqueInput
|
|
update?: XOR<XOR<AdminUpdateToOneWithWhereWithoutAuditLogsInput, AdminUpdateWithoutAuditLogsInput>, AdminUncheckedUpdateWithoutAuditLogsInput>
|
|
}
|
|
|
|
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 NestedEnumAdminRoleFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminRoleFilter<$PrismaModel> | $Enums.AdminRole
|
|
}
|
|
|
|
export type NestedEnumAdminStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminStatus | EnumAdminStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminStatusFilter<$PrismaModel> | $Enums.AdminStatus
|
|
}
|
|
|
|
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 NestedEnumAdminRoleWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminRoleWithAggregatesFilter<$PrismaModel> | $Enums.AdminRole
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumAdminRoleFilter<$PrismaModel>
|
|
_max?: NestedEnumAdminRoleFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumAdminStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.AdminStatus | EnumAdminStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.AdminStatus[] | ListEnumAdminStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumAdminStatusWithAggregatesFilter<$PrismaModel> | $Enums.AdminStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumAdminStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumAdminStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
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 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 NestedEnumUserStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserStatus | EnumUserStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserStatusFilter<$PrismaModel> | $Enums.UserStatus
|
|
}
|
|
|
|
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 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 NestedEnumUserStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserStatus | EnumUserStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserStatus[] | ListEnumUserStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserStatusWithAggregatesFilter<$PrismaModel> | $Enums.UserStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumUserStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumUserStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
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 NestedBoolFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolFilter<$PrismaModel> | boolean
|
|
}
|
|
|
|
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 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 NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: boolean | BooleanFieldRefInput<$PrismaModel>
|
|
not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedBoolFilter<$PrismaModel>
|
|
_max?: NestedBoolFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumCampaignStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CampaignStatus | EnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCampaignStatusFilter<$PrismaModel> | $Enums.CampaignStatus
|
|
}
|
|
|
|
export type NestedEnumWheelDesignFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.WheelDesign | EnumWheelDesignFieldRefInput<$PrismaModel>
|
|
in?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumWheelDesignFilter<$PrismaModel> | $Enums.WheelDesign
|
|
}
|
|
|
|
export type NestedEnumCampaignStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.CampaignStatus | EnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.CampaignStatus[] | ListEnumCampaignStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumCampaignStatusWithAggregatesFilter<$PrismaModel> | $Enums.CampaignStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumCampaignStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumCampaignStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumWheelDesignWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.WheelDesign | EnumWheelDesignFieldRefInput<$PrismaModel>
|
|
in?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.WheelDesign[] | ListEnumWheelDesignFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumWheelDesignWithAggregatesFilter<$PrismaModel> | $Enums.WheelDesign
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumWheelDesignFilter<$PrismaModel>
|
|
_max?: NestedEnumWheelDesignFilter<$PrismaModel>
|
|
}
|
|
export type NestedJsonNullableFilter<$PrismaModel = never> =
|
|
| PatchUndefined<
|
|
Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
|
|
Required<NestedJsonNullableFilterBase<$PrismaModel>>
|
|
>
|
|
| OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>
|
|
|
|
export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
|
|
equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
|
|
path?: string[]
|
|
string_contains?: string | StringFieldRefInput<$PrismaModel>
|
|
string_starts_with?: string | StringFieldRefInput<$PrismaModel>
|
|
string_ends_with?: string | StringFieldRefInput<$PrismaModel>
|
|
array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
|
|
array_ends_with?: 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 NestedEnumPrizeTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeType | EnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeTypeFilter<$PrismaModel> | $Enums.PrizeType
|
|
}
|
|
|
|
export type NestedEnumStockTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.StockType | EnumStockTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumStockTypeFilter<$PrismaModel> | $Enums.StockType
|
|
}
|
|
|
|
export type NestedEnumPrizeStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeStatus | EnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeStatusFilter<$PrismaModel> | $Enums.PrizeStatus
|
|
}
|
|
|
|
export type NestedEnumPrizeTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeType | EnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeType[] | ListEnumPrizeTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeTypeWithAggregatesFilter<$PrismaModel> | $Enums.PrizeType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumPrizeTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumPrizeTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumStockTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.StockType | EnumStockTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.StockType[] | ListEnumStockTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumStockTypeWithAggregatesFilter<$PrismaModel> | $Enums.StockType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumStockTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumStockTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
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 NestedEnumPrizeStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.PrizeStatus | EnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.PrizeStatus[] | ListEnumPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumPrizeStatusWithAggregatesFilter<$PrismaModel> | $Enums.PrizeStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumPrizeStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumPrizeStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumChanceTxnTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.ChanceTxnType | EnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumChanceTxnTypeFilter<$PrismaModel> | $Enums.ChanceTxnType
|
|
}
|
|
|
|
export type NestedEnumChanceTxnTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.ChanceTxnType | EnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.ChanceTxnType[] | ListEnumChanceTxnTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumChanceTxnTypeWithAggregatesFilter<$PrismaModel> | $Enums.ChanceTxnType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumChanceTxnTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumChanceTxnTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumSpinStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SpinStatus | EnumSpinStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSpinStatusFilter<$PrismaModel> | $Enums.SpinStatus
|
|
}
|
|
|
|
export type NestedEnumSpinStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SpinStatus | EnumSpinStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SpinStatus[] | ListEnumSpinStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSpinStatusWithAggregatesFilter<$PrismaModel> | $Enums.SpinStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumSpinStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumSpinStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumUserPrizeStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserPrizeStatus | EnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserPrizeStatusFilter<$PrismaModel> | $Enums.UserPrizeStatus
|
|
}
|
|
|
|
export type NestedEnumUserPrizeStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.UserPrizeStatus | EnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.UserPrizeStatus[] | ListEnumUserPrizeStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumUserPrizeStatusWithAggregatesFilter<$PrismaModel> | $Enums.UserPrizeStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumUserPrizeStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumUserPrizeStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumSmsTypeFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsType | EnumSmsTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsTypeFilter<$PrismaModel> | $Enums.SmsType
|
|
}
|
|
|
|
export type NestedEnumSmsStatusFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsStatus | EnumSmsStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsStatusFilter<$PrismaModel> | $Enums.SmsStatus
|
|
}
|
|
|
|
export type NestedEnumSmsTypeWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsType | EnumSmsTypeFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsType[] | ListEnumSmsTypeFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsTypeWithAggregatesFilter<$PrismaModel> | $Enums.SmsType
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumSmsTypeFilter<$PrismaModel>
|
|
_max?: NestedEnumSmsTypeFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedEnumSmsStatusWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: $Enums.SmsStatus | EnumSmsStatusFieldRefInput<$PrismaModel>
|
|
in?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
notIn?: $Enums.SmsStatus[] | ListEnumSmsStatusFieldRefInput<$PrismaModel>
|
|
not?: NestedEnumSmsStatusWithAggregatesFilter<$PrismaModel> | $Enums.SmsStatus
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_min?: NestedEnumSmsStatusFilter<$PrismaModel>
|
|
_max?: NestedEnumSmsStatusFilter<$PrismaModel>
|
|
}
|
|
|
|
export type AdminLogCreateWithoutAdminInput = {
|
|
id?: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AdminLogUncheckedCreateWithoutAdminInput = {
|
|
id?: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AdminLogCreateOrConnectWithoutAdminInput = {
|
|
where: AdminLogWhereUniqueInput
|
|
create: XOR<AdminLogCreateWithoutAdminInput, AdminLogUncheckedCreateWithoutAdminInput>
|
|
}
|
|
|
|
export type AdminLogCreateManyAdminInputEnvelope = {
|
|
data: AdminLogCreateManyAdminInput | AdminLogCreateManyAdminInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ChanceTransactionCreateWithoutCreatedByInput = {
|
|
id?: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutChanceTransactionsInput
|
|
campaign: CampaignCreateNestedOneWithoutChanceTxnsInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateWithoutCreatedByInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateOrConnectWithoutCreatedByInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
create: XOR<ChanceTransactionCreateWithoutCreatedByInput, ChanceTransactionUncheckedCreateWithoutCreatedByInput>
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyCreatedByInputEnvelope = {
|
|
data: ChanceTransactionCreateManyCreatedByInput | ChanceTransactionCreateManyCreatedByInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type AdminLogUpsertWithWhereUniqueWithoutAdminInput = {
|
|
where: AdminLogWhereUniqueInput
|
|
update: XOR<AdminLogUpdateWithoutAdminInput, AdminLogUncheckedUpdateWithoutAdminInput>
|
|
create: XOR<AdminLogCreateWithoutAdminInput, AdminLogUncheckedCreateWithoutAdminInput>
|
|
}
|
|
|
|
export type AdminLogUpdateWithWhereUniqueWithoutAdminInput = {
|
|
where: AdminLogWhereUniqueInput
|
|
data: XOR<AdminLogUpdateWithoutAdminInput, AdminLogUncheckedUpdateWithoutAdminInput>
|
|
}
|
|
|
|
export type AdminLogUpdateManyWithWhereWithoutAdminInput = {
|
|
where: AdminLogScalarWhereInput
|
|
data: XOR<AdminLogUpdateManyMutationInput, AdminLogUncheckedUpdateManyWithoutAdminInput>
|
|
}
|
|
|
|
export type AdminLogScalarWhereInput = {
|
|
AND?: AdminLogScalarWhereInput | AdminLogScalarWhereInput[]
|
|
OR?: AdminLogScalarWhereInput[]
|
|
NOT?: AdminLogScalarWhereInput | AdminLogScalarWhereInput[]
|
|
id?: StringFilter<"AdminLog"> | string
|
|
adminId?: StringFilter<"AdminLog"> | string
|
|
action?: StringFilter<"AdminLog"> | string
|
|
entityType?: StringFilter<"AdminLog"> | string
|
|
entityId?: StringFilter<"AdminLog"> | string
|
|
oldValue?: JsonNullableFilter<"AdminLog">
|
|
newValue?: JsonNullableFilter<"AdminLog">
|
|
ip?: StringNullableFilter<"AdminLog"> | string | null
|
|
createdAt?: DateTimeFilter<"AdminLog"> | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpsertWithWhereUniqueWithoutCreatedByInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
update: XOR<ChanceTransactionUpdateWithoutCreatedByInput, ChanceTransactionUncheckedUpdateWithoutCreatedByInput>
|
|
create: XOR<ChanceTransactionCreateWithoutCreatedByInput, ChanceTransactionUncheckedCreateWithoutCreatedByInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpdateWithWhereUniqueWithoutCreatedByInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
data: XOR<ChanceTransactionUpdateWithoutCreatedByInput, ChanceTransactionUncheckedUpdateWithoutCreatedByInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyWithWhereWithoutCreatedByInput = {
|
|
where: ChanceTransactionScalarWhereInput
|
|
data: XOR<ChanceTransactionUpdateManyMutationInput, ChanceTransactionUncheckedUpdateManyWithoutCreatedByInput>
|
|
}
|
|
|
|
export type ChanceTransactionScalarWhereInput = {
|
|
AND?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
OR?: ChanceTransactionScalarWhereInput[]
|
|
NOT?: ChanceTransactionScalarWhereInput | ChanceTransactionScalarWhereInput[]
|
|
id?: StringFilter<"ChanceTransaction"> | string
|
|
userId?: StringFilter<"ChanceTransaction"> | string
|
|
campaignId?: StringFilter<"ChanceTransaction"> | string
|
|
amount?: IntFilter<"ChanceTransaction"> | number
|
|
type?: EnumChanceTxnTypeFilter<"ChanceTransaction"> | $Enums.ChanceTxnType
|
|
referenceType?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
referenceId?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
description?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
createdById?: StringNullableFilter<"ChanceTransaction"> | string | null
|
|
createdAt?: DateTimeFilter<"ChanceTransaction"> | Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateWithoutUserInput = {
|
|
id?: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
campaign: CampaignCreateNestedOneWithoutUserCampaignsInput
|
|
}
|
|
|
|
export type UserCampaignUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateOrConnectWithoutUserInput = {
|
|
where: UserCampaignWhereUniqueInput
|
|
create: XOR<UserCampaignCreateWithoutUserInput, UserCampaignUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type UserCampaignCreateManyUserInputEnvelope = {
|
|
data: UserCampaignCreateManyUserInput | UserCampaignCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ChanceTransactionCreateWithoutUserInput = {
|
|
id?: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdAt?: Date | string
|
|
campaign: CampaignCreateNestedOneWithoutChanceTxnsInput
|
|
createdBy?: AdminCreateNestedOneWithoutChanceTxnsInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdById?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateOrConnectWithoutUserInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
create: XOR<ChanceTransactionCreateWithoutUserInput, ChanceTransactionUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyUserInputEnvelope = {
|
|
data: ChanceTransactionCreateManyUserInput | ChanceTransactionCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type SpinCreateWithoutUserInput = {
|
|
id?: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
campaign: CampaignCreateNestedOneWithoutSpinsInput
|
|
prize?: PrizeCreateNestedOneWithoutSpinsInput
|
|
userPrize?: UserPrizeCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
userPrize?: UserPrizeUncheckedCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinCreateOrConnectWithoutUserInput = {
|
|
where: SpinWhereUniqueInput
|
|
create: XOR<SpinCreateWithoutUserInput, SpinUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type SpinCreateManyUserInputEnvelope = {
|
|
data: SpinCreateManyUserInput | SpinCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type UserPrizeCreateWithoutUserInput = {
|
|
id?: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
campaign: CampaignCreateNestedOneWithoutUserPrizesInput
|
|
prize: PrizeCreateNestedOneWithoutUserPrizesInput
|
|
spin: SpinCreateNestedOneWithoutUserPrizeInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type UserPrizeCreateOrConnectWithoutUserInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
create: XOR<UserPrizeCreateWithoutUserInput, UserPrizeUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type UserPrizeCreateManyUserInputEnvelope = {
|
|
data: UserPrizeCreateManyUserInput | UserPrizeCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type OtpCodeCreateWithoutUserInput = {
|
|
id?: string
|
|
mobile: string
|
|
code: string
|
|
attempts?: number
|
|
consumed?: boolean
|
|
expiresAt: Date | string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type OtpCodeUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
mobile: string
|
|
code: string
|
|
attempts?: number
|
|
consumed?: boolean
|
|
expiresAt: Date | string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type OtpCodeCreateOrConnectWithoutUserInput = {
|
|
where: OtpCodeWhereUniqueInput
|
|
create: XOR<OtpCodeCreateWithoutUserInput, OtpCodeUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type OtpCodeCreateManyUserInputEnvelope = {
|
|
data: OtpCodeCreateManyUserInput | OtpCodeCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type SmsLogCreateWithoutUserInput = {
|
|
id?: string
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider?: string
|
|
status?: $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SmsLogUncheckedCreateWithoutUserInput = {
|
|
id?: string
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider?: string
|
|
status?: $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SmsLogCreateOrConnectWithoutUserInput = {
|
|
where: SmsLogWhereUniqueInput
|
|
create: XOR<SmsLogCreateWithoutUserInput, SmsLogUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type SmsLogCreateManyUserInputEnvelope = {
|
|
data: SmsLogCreateManyUserInput | SmsLogCreateManyUserInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type UserCampaignUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: UserCampaignWhereUniqueInput
|
|
update: XOR<UserCampaignUpdateWithoutUserInput, UserCampaignUncheckedUpdateWithoutUserInput>
|
|
create: XOR<UserCampaignCreateWithoutUserInput, UserCampaignUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type UserCampaignUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: UserCampaignWhereUniqueInput
|
|
data: XOR<UserCampaignUpdateWithoutUserInput, UserCampaignUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type UserCampaignUpdateManyWithWhereWithoutUserInput = {
|
|
where: UserCampaignScalarWhereInput
|
|
data: XOR<UserCampaignUpdateManyMutationInput, UserCampaignUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type UserCampaignScalarWhereInput = {
|
|
AND?: UserCampaignScalarWhereInput | UserCampaignScalarWhereInput[]
|
|
OR?: UserCampaignScalarWhereInput[]
|
|
NOT?: UserCampaignScalarWhereInput | UserCampaignScalarWhereInput[]
|
|
id?: StringFilter<"UserCampaign"> | string
|
|
userId?: StringFilter<"UserCampaign"> | string
|
|
campaignId?: StringFilter<"UserCampaign"> | string
|
|
totalChances?: IntFilter<"UserCampaign"> | number
|
|
usedChances?: IntFilter<"UserCampaign"> | number
|
|
createdAt?: DateTimeFilter<"UserCampaign"> | Date | string
|
|
updatedAt?: DateTimeFilter<"UserCampaign"> | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
update: XOR<ChanceTransactionUpdateWithoutUserInput, ChanceTransactionUncheckedUpdateWithoutUserInput>
|
|
create: XOR<ChanceTransactionCreateWithoutUserInput, ChanceTransactionUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
data: XOR<ChanceTransactionUpdateWithoutUserInput, ChanceTransactionUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyWithWhereWithoutUserInput = {
|
|
where: ChanceTransactionScalarWhereInput
|
|
data: XOR<ChanceTransactionUpdateManyMutationInput, ChanceTransactionUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type SpinUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: SpinWhereUniqueInput
|
|
update: XOR<SpinUpdateWithoutUserInput, SpinUncheckedUpdateWithoutUserInput>
|
|
create: XOR<SpinCreateWithoutUserInput, SpinUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type SpinUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: SpinWhereUniqueInput
|
|
data: XOR<SpinUpdateWithoutUserInput, SpinUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type SpinUpdateManyWithWhereWithoutUserInput = {
|
|
where: SpinScalarWhereInput
|
|
data: XOR<SpinUpdateManyMutationInput, SpinUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type SpinScalarWhereInput = {
|
|
AND?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
OR?: SpinScalarWhereInput[]
|
|
NOT?: SpinScalarWhereInput | SpinScalarWhereInput[]
|
|
id?: StringFilter<"Spin"> | string
|
|
userId?: StringFilter<"Spin"> | string
|
|
campaignId?: StringFilter<"Spin"> | string
|
|
prizeId?: StringNullableFilter<"Spin"> | string | null
|
|
status?: EnumSpinStatusFilter<"Spin"> | $Enums.SpinStatus
|
|
idempotencyKey?: StringFilter<"Spin"> | string
|
|
ip?: StringNullableFilter<"Spin"> | string | null
|
|
userAgent?: StringNullableFilter<"Spin"> | string | null
|
|
createdAt?: DateTimeFilter<"Spin"> | Date | string
|
|
}
|
|
|
|
export type UserPrizeUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
update: XOR<UserPrizeUpdateWithoutUserInput, UserPrizeUncheckedUpdateWithoutUserInput>
|
|
create: XOR<UserPrizeCreateWithoutUserInput, UserPrizeUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
data: XOR<UserPrizeUpdateWithoutUserInput, UserPrizeUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateManyWithWhereWithoutUserInput = {
|
|
where: UserPrizeScalarWhereInput
|
|
data: XOR<UserPrizeUpdateManyMutationInput, UserPrizeUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type UserPrizeScalarWhereInput = {
|
|
AND?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
OR?: UserPrizeScalarWhereInput[]
|
|
NOT?: UserPrizeScalarWhereInput | UserPrizeScalarWhereInput[]
|
|
id?: StringFilter<"UserPrize"> | string
|
|
userId?: StringFilter<"UserPrize"> | string
|
|
campaignId?: StringFilter<"UserPrize"> | string
|
|
prizeId?: StringFilter<"UserPrize"> | string
|
|
spinId?: StringFilter<"UserPrize"> | string
|
|
code?: StringNullableFilter<"UserPrize"> | string | null
|
|
status?: EnumUserPrizeStatusFilter<"UserPrize"> | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFilter<"UserPrize"> | Date | string
|
|
redeemedAt?: DateTimeNullableFilter<"UserPrize"> | Date | string | null
|
|
}
|
|
|
|
export type OtpCodeUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: OtpCodeWhereUniqueInput
|
|
update: XOR<OtpCodeUpdateWithoutUserInput, OtpCodeUncheckedUpdateWithoutUserInput>
|
|
create: XOR<OtpCodeCreateWithoutUserInput, OtpCodeUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type OtpCodeUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: OtpCodeWhereUniqueInput
|
|
data: XOR<OtpCodeUpdateWithoutUserInput, OtpCodeUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type OtpCodeUpdateManyWithWhereWithoutUserInput = {
|
|
where: OtpCodeScalarWhereInput
|
|
data: XOR<OtpCodeUpdateManyMutationInput, OtpCodeUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type OtpCodeScalarWhereInput = {
|
|
AND?: OtpCodeScalarWhereInput | OtpCodeScalarWhereInput[]
|
|
OR?: OtpCodeScalarWhereInput[]
|
|
NOT?: OtpCodeScalarWhereInput | OtpCodeScalarWhereInput[]
|
|
id?: StringFilter<"OtpCode"> | string
|
|
mobile?: StringFilter<"OtpCode"> | string
|
|
code?: StringFilter<"OtpCode"> | string
|
|
userId?: StringNullableFilter<"OtpCode"> | string | null
|
|
attempts?: IntFilter<"OtpCode"> | number
|
|
consumed?: BoolFilter<"OtpCode"> | boolean
|
|
expiresAt?: DateTimeFilter<"OtpCode"> | Date | string
|
|
createdAt?: DateTimeFilter<"OtpCode"> | Date | string
|
|
}
|
|
|
|
export type SmsLogUpsertWithWhereUniqueWithoutUserInput = {
|
|
where: SmsLogWhereUniqueInput
|
|
update: XOR<SmsLogUpdateWithoutUserInput, SmsLogUncheckedUpdateWithoutUserInput>
|
|
create: XOR<SmsLogCreateWithoutUserInput, SmsLogUncheckedCreateWithoutUserInput>
|
|
}
|
|
|
|
export type SmsLogUpdateWithWhereUniqueWithoutUserInput = {
|
|
where: SmsLogWhereUniqueInput
|
|
data: XOR<SmsLogUpdateWithoutUserInput, SmsLogUncheckedUpdateWithoutUserInput>
|
|
}
|
|
|
|
export type SmsLogUpdateManyWithWhereWithoutUserInput = {
|
|
where: SmsLogScalarWhereInput
|
|
data: XOR<SmsLogUpdateManyMutationInput, SmsLogUncheckedUpdateManyWithoutUserInput>
|
|
}
|
|
|
|
export type SmsLogScalarWhereInput = {
|
|
AND?: SmsLogScalarWhereInput | SmsLogScalarWhereInput[]
|
|
OR?: SmsLogScalarWhereInput[]
|
|
NOT?: SmsLogScalarWhereInput | SmsLogScalarWhereInput[]
|
|
id?: StringFilter<"SmsLog"> | string
|
|
userId?: StringNullableFilter<"SmsLog"> | string | null
|
|
mobile?: StringFilter<"SmsLog"> | string
|
|
type?: EnumSmsTypeFilter<"SmsLog"> | $Enums.SmsType
|
|
message?: StringFilter<"SmsLog"> | string
|
|
provider?: StringFilter<"SmsLog"> | string
|
|
status?: EnumSmsStatusFilter<"SmsLog"> | $Enums.SmsStatus
|
|
providerResponse?: JsonNullableFilter<"SmsLog">
|
|
createdAt?: DateTimeFilter<"SmsLog"> | Date | string
|
|
}
|
|
|
|
export type UserCreateWithoutOtpCodesInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionCreateNestedManyWithoutUserInput
|
|
spins?: SpinCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutOtpCodesInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionUncheckedCreateNestedManyWithoutUserInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutOtpCodesInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutOtpCodesInput, UserUncheckedCreateWithoutOtpCodesInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutOtpCodesInput = {
|
|
update: XOR<UserUpdateWithoutOtpCodesInput, UserUncheckedUpdateWithoutOtpCodesInput>
|
|
create: XOR<UserCreateWithoutOtpCodesInput, UserUncheckedCreateWithoutOtpCodesInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutOtpCodesInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutOtpCodesInput, UserUncheckedUpdateWithoutOtpCodesInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutOtpCodesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutOtpCodesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type PrizeCreateWithoutCampaignInput = {
|
|
id?: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
spins?: SpinCreateNestedManyWithoutPrizeInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeUncheckedCreateWithoutCampaignInput = {
|
|
id?: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
spins?: SpinUncheckedCreateNestedManyWithoutPrizeInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeCreateOrConnectWithoutCampaignInput = {
|
|
where: PrizeWhereUniqueInput
|
|
create: XOR<PrizeCreateWithoutCampaignInput, PrizeUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type PrizeCreateManyCampaignInputEnvelope = {
|
|
data: PrizeCreateManyCampaignInput | PrizeCreateManyCampaignInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type UserCampaignCreateWithoutCampaignInput = {
|
|
id?: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
user: UserCreateNestedOneWithoutUserCampaignsInput
|
|
}
|
|
|
|
export type UserCampaignUncheckedCreateWithoutCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateOrConnectWithoutCampaignInput = {
|
|
where: UserCampaignWhereUniqueInput
|
|
create: XOR<UserCampaignCreateWithoutCampaignInput, UserCampaignUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserCampaignCreateManyCampaignInputEnvelope = {
|
|
data: UserCampaignCreateManyCampaignInput | UserCampaignCreateManyCampaignInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type ChanceTransactionCreateWithoutCampaignInput = {
|
|
id?: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutChanceTransactionsInput
|
|
createdBy?: AdminCreateNestedOneWithoutChanceTxnsInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedCreateWithoutCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdById?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateOrConnectWithoutCampaignInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
create: XOR<ChanceTransactionCreateWithoutCampaignInput, ChanceTransactionUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyCampaignInputEnvelope = {
|
|
data: ChanceTransactionCreateManyCampaignInput | ChanceTransactionCreateManyCampaignInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type SpinCreateWithoutCampaignInput = {
|
|
id?: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutSpinsInput
|
|
prize?: PrizeCreateNestedOneWithoutSpinsInput
|
|
userPrize?: UserPrizeCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinUncheckedCreateWithoutCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
userPrize?: UserPrizeUncheckedCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinCreateOrConnectWithoutCampaignInput = {
|
|
where: SpinWhereUniqueInput
|
|
create: XOR<SpinCreateWithoutCampaignInput, SpinUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type SpinCreateManyCampaignInputEnvelope = {
|
|
data: SpinCreateManyCampaignInput | SpinCreateManyCampaignInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type UserPrizeCreateWithoutCampaignInput = {
|
|
id?: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
user: UserCreateNestedOneWithoutUserPrizesInput
|
|
prize: PrizeCreateNestedOneWithoutUserPrizesInput
|
|
spin: SpinCreateNestedOneWithoutUserPrizeInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateWithoutCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type UserPrizeCreateOrConnectWithoutCampaignInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
create: XOR<UserPrizeCreateWithoutCampaignInput, UserPrizeUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserPrizeCreateManyCampaignInputEnvelope = {
|
|
data: UserPrizeCreateManyCampaignInput | UserPrizeCreateManyCampaignInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type PrizeUpsertWithWhereUniqueWithoutCampaignInput = {
|
|
where: PrizeWhereUniqueInput
|
|
update: XOR<PrizeUpdateWithoutCampaignInput, PrizeUncheckedUpdateWithoutCampaignInput>
|
|
create: XOR<PrizeCreateWithoutCampaignInput, PrizeUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type PrizeUpdateWithWhereUniqueWithoutCampaignInput = {
|
|
where: PrizeWhereUniqueInput
|
|
data: XOR<PrizeUpdateWithoutCampaignInput, PrizeUncheckedUpdateWithoutCampaignInput>
|
|
}
|
|
|
|
export type PrizeUpdateManyWithWhereWithoutCampaignInput = {
|
|
where: PrizeScalarWhereInput
|
|
data: XOR<PrizeUpdateManyMutationInput, PrizeUncheckedUpdateManyWithoutCampaignInput>
|
|
}
|
|
|
|
export type PrizeScalarWhereInput = {
|
|
AND?: PrizeScalarWhereInput | PrizeScalarWhereInput[]
|
|
OR?: PrizeScalarWhereInput[]
|
|
NOT?: PrizeScalarWhereInput | PrizeScalarWhereInput[]
|
|
id?: StringFilter<"Prize"> | string
|
|
campaignId?: StringFilter<"Prize"> | string
|
|
title?: StringFilter<"Prize"> | string
|
|
description?: StringNullableFilter<"Prize"> | string | null
|
|
image?: StringNullableFilter<"Prize"> | string | null
|
|
type?: EnumPrizeTypeFilter<"Prize"> | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFilter<"Prize"> | $Enums.StockType
|
|
initialStock?: IntNullableFilter<"Prize"> | number | null
|
|
remainingStock?: IntNullableFilter<"Prize"> | number | null
|
|
weight?: IntFilter<"Prize"> | number
|
|
status?: EnumPrizeStatusFilter<"Prize"> | $Enums.PrizeStatus
|
|
sortOrder?: IntFilter<"Prize"> | number
|
|
segmentColor?: StringFilter<"Prize"> | string
|
|
expiresAt?: DateTimeNullableFilter<"Prize"> | Date | string | null
|
|
smsTemplate?: StringNullableFilter<"Prize"> | string | null
|
|
createdAt?: DateTimeFilter<"Prize"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Prize"> | Date | string
|
|
}
|
|
|
|
export type UserCampaignUpsertWithWhereUniqueWithoutCampaignInput = {
|
|
where: UserCampaignWhereUniqueInput
|
|
update: XOR<UserCampaignUpdateWithoutCampaignInput, UserCampaignUncheckedUpdateWithoutCampaignInput>
|
|
create: XOR<UserCampaignCreateWithoutCampaignInput, UserCampaignUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserCampaignUpdateWithWhereUniqueWithoutCampaignInput = {
|
|
where: UserCampaignWhereUniqueInput
|
|
data: XOR<UserCampaignUpdateWithoutCampaignInput, UserCampaignUncheckedUpdateWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserCampaignUpdateManyWithWhereWithoutCampaignInput = {
|
|
where: UserCampaignScalarWhereInput
|
|
data: XOR<UserCampaignUpdateManyMutationInput, UserCampaignUncheckedUpdateManyWithoutCampaignInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpsertWithWhereUniqueWithoutCampaignInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
update: XOR<ChanceTransactionUpdateWithoutCampaignInput, ChanceTransactionUncheckedUpdateWithoutCampaignInput>
|
|
create: XOR<ChanceTransactionCreateWithoutCampaignInput, ChanceTransactionUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpdateWithWhereUniqueWithoutCampaignInput = {
|
|
where: ChanceTransactionWhereUniqueInput
|
|
data: XOR<ChanceTransactionUpdateWithoutCampaignInput, ChanceTransactionUncheckedUpdateWithoutCampaignInput>
|
|
}
|
|
|
|
export type ChanceTransactionUpdateManyWithWhereWithoutCampaignInput = {
|
|
where: ChanceTransactionScalarWhereInput
|
|
data: XOR<ChanceTransactionUpdateManyMutationInput, ChanceTransactionUncheckedUpdateManyWithoutCampaignInput>
|
|
}
|
|
|
|
export type SpinUpsertWithWhereUniqueWithoutCampaignInput = {
|
|
where: SpinWhereUniqueInput
|
|
update: XOR<SpinUpdateWithoutCampaignInput, SpinUncheckedUpdateWithoutCampaignInput>
|
|
create: XOR<SpinCreateWithoutCampaignInput, SpinUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type SpinUpdateWithWhereUniqueWithoutCampaignInput = {
|
|
where: SpinWhereUniqueInput
|
|
data: XOR<SpinUpdateWithoutCampaignInput, SpinUncheckedUpdateWithoutCampaignInput>
|
|
}
|
|
|
|
export type SpinUpdateManyWithWhereWithoutCampaignInput = {
|
|
where: SpinScalarWhereInput
|
|
data: XOR<SpinUpdateManyMutationInput, SpinUncheckedUpdateManyWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserPrizeUpsertWithWhereUniqueWithoutCampaignInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
update: XOR<UserPrizeUpdateWithoutCampaignInput, UserPrizeUncheckedUpdateWithoutCampaignInput>
|
|
create: XOR<UserPrizeCreateWithoutCampaignInput, UserPrizeUncheckedCreateWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateWithWhereUniqueWithoutCampaignInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
data: XOR<UserPrizeUpdateWithoutCampaignInput, UserPrizeUncheckedUpdateWithoutCampaignInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateManyWithWhereWithoutCampaignInput = {
|
|
where: UserPrizeScalarWhereInput
|
|
data: XOR<UserPrizeUpdateManyMutationInput, UserPrizeUncheckedUpdateManyWithoutCampaignInput>
|
|
}
|
|
|
|
export type CampaignCreateWithoutPrizesInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUncheckedCreateWithoutPrizesInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignCreateOrConnectWithoutPrizesInput = {
|
|
where: CampaignWhereUniqueInput
|
|
create: XOR<CampaignCreateWithoutPrizesInput, CampaignUncheckedCreateWithoutPrizesInput>
|
|
}
|
|
|
|
export type SpinCreateWithoutPrizeInput = {
|
|
id?: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutSpinsInput
|
|
campaign: CampaignCreateNestedOneWithoutSpinsInput
|
|
userPrize?: UserPrizeCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinUncheckedCreateWithoutPrizeInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
userPrize?: UserPrizeUncheckedCreateNestedOneWithoutSpinInput
|
|
}
|
|
|
|
export type SpinCreateOrConnectWithoutPrizeInput = {
|
|
where: SpinWhereUniqueInput
|
|
create: XOR<SpinCreateWithoutPrizeInput, SpinUncheckedCreateWithoutPrizeInput>
|
|
}
|
|
|
|
export type SpinCreateManyPrizeInputEnvelope = {
|
|
data: SpinCreateManyPrizeInput | SpinCreateManyPrizeInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type UserPrizeCreateWithoutPrizeInput = {
|
|
id?: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
user: UserCreateNestedOneWithoutUserPrizesInput
|
|
campaign: CampaignCreateNestedOneWithoutUserPrizesInput
|
|
spin: SpinCreateNestedOneWithoutUserPrizeInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateWithoutPrizeInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type UserPrizeCreateOrConnectWithoutPrizeInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
create: XOR<UserPrizeCreateWithoutPrizeInput, UserPrizeUncheckedCreateWithoutPrizeInput>
|
|
}
|
|
|
|
export type UserPrizeCreateManyPrizeInputEnvelope = {
|
|
data: UserPrizeCreateManyPrizeInput | UserPrizeCreateManyPrizeInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type CampaignUpsertWithoutPrizesInput = {
|
|
update: XOR<CampaignUpdateWithoutPrizesInput, CampaignUncheckedUpdateWithoutPrizesInput>
|
|
create: XOR<CampaignCreateWithoutPrizesInput, CampaignUncheckedCreateWithoutPrizesInput>
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
export type CampaignUpdateToOneWithWhereWithoutPrizesInput = {
|
|
where?: CampaignWhereInput
|
|
data: XOR<CampaignUpdateWithoutPrizesInput, CampaignUncheckedUpdateWithoutPrizesInput>
|
|
}
|
|
|
|
export type CampaignUpdateWithoutPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateWithoutPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type SpinUpsertWithWhereUniqueWithoutPrizeInput = {
|
|
where: SpinWhereUniqueInput
|
|
update: XOR<SpinUpdateWithoutPrizeInput, SpinUncheckedUpdateWithoutPrizeInput>
|
|
create: XOR<SpinCreateWithoutPrizeInput, SpinUncheckedCreateWithoutPrizeInput>
|
|
}
|
|
|
|
export type SpinUpdateWithWhereUniqueWithoutPrizeInput = {
|
|
where: SpinWhereUniqueInput
|
|
data: XOR<SpinUpdateWithoutPrizeInput, SpinUncheckedUpdateWithoutPrizeInput>
|
|
}
|
|
|
|
export type SpinUpdateManyWithWhereWithoutPrizeInput = {
|
|
where: SpinScalarWhereInput
|
|
data: XOR<SpinUpdateManyMutationInput, SpinUncheckedUpdateManyWithoutPrizeInput>
|
|
}
|
|
|
|
export type UserPrizeUpsertWithWhereUniqueWithoutPrizeInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
update: XOR<UserPrizeUpdateWithoutPrizeInput, UserPrizeUncheckedUpdateWithoutPrizeInput>
|
|
create: XOR<UserPrizeCreateWithoutPrizeInput, UserPrizeUncheckedCreateWithoutPrizeInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateWithWhereUniqueWithoutPrizeInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
data: XOR<UserPrizeUpdateWithoutPrizeInput, UserPrizeUncheckedUpdateWithoutPrizeInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateManyWithWhereWithoutPrizeInput = {
|
|
where: UserPrizeScalarWhereInput
|
|
data: XOR<UserPrizeUpdateManyMutationInput, UserPrizeUncheckedUpdateManyWithoutPrizeInput>
|
|
}
|
|
|
|
export type UserCreateWithoutUserCampaignsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
chanceTransactions?: ChanceTransactionCreateNestedManyWithoutUserInput
|
|
spins?: SpinCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutUserCampaignsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
chanceTransactions?: ChanceTransactionUncheckedCreateNestedManyWithoutUserInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeUncheckedCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutUserCampaignsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutUserCampaignsInput, UserUncheckedCreateWithoutUserCampaignsInput>
|
|
}
|
|
|
|
export type CampaignCreateWithoutUserCampaignsInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUncheckedCreateWithoutUserCampaignsInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignCreateOrConnectWithoutUserCampaignsInput = {
|
|
where: CampaignWhereUniqueInput
|
|
create: XOR<CampaignCreateWithoutUserCampaignsInput, CampaignUncheckedCreateWithoutUserCampaignsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutUserCampaignsInput = {
|
|
update: XOR<UserUpdateWithoutUserCampaignsInput, UserUncheckedUpdateWithoutUserCampaignsInput>
|
|
create: XOR<UserCreateWithoutUserCampaignsInput, UserUncheckedCreateWithoutUserCampaignsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutUserCampaignsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutUserCampaignsInput, UserUncheckedUpdateWithoutUserCampaignsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutUserCampaignsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
chanceTransactions?: ChanceTransactionUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutUserCampaignsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
chanceTransactions?: ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUncheckedUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type CampaignUpsertWithoutUserCampaignsInput = {
|
|
update: XOR<CampaignUpdateWithoutUserCampaignsInput, CampaignUncheckedUpdateWithoutUserCampaignsInput>
|
|
create: XOR<CampaignCreateWithoutUserCampaignsInput, CampaignUncheckedCreateWithoutUserCampaignsInput>
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
export type CampaignUpdateToOneWithWhereWithoutUserCampaignsInput = {
|
|
where?: CampaignWhereInput
|
|
data: XOR<CampaignUpdateWithoutUserCampaignsInput, CampaignUncheckedUpdateWithoutUserCampaignsInput>
|
|
}
|
|
|
|
export type CampaignUpdateWithoutUserCampaignsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateWithoutUserCampaignsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type UserCreateWithoutChanceTransactionsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutUserInput
|
|
spins?: SpinCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutChanceTransactionsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutUserInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeUncheckedCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutChanceTransactionsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutChanceTransactionsInput, UserUncheckedCreateWithoutChanceTransactionsInput>
|
|
}
|
|
|
|
export type CampaignCreateWithoutChanceTxnsInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUncheckedCreateWithoutChanceTxnsInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignCreateOrConnectWithoutChanceTxnsInput = {
|
|
where: CampaignWhereUniqueInput
|
|
create: XOR<CampaignCreateWithoutChanceTxnsInput, CampaignUncheckedCreateWithoutChanceTxnsInput>
|
|
}
|
|
|
|
export type AdminCreateWithoutChanceTxnsInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
auditLogs?: AdminLogCreateNestedManyWithoutAdminInput
|
|
}
|
|
|
|
export type AdminUncheckedCreateWithoutChanceTxnsInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
auditLogs?: AdminLogUncheckedCreateNestedManyWithoutAdminInput
|
|
}
|
|
|
|
export type AdminCreateOrConnectWithoutChanceTxnsInput = {
|
|
where: AdminWhereUniqueInput
|
|
create: XOR<AdminCreateWithoutChanceTxnsInput, AdminUncheckedCreateWithoutChanceTxnsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutChanceTransactionsInput = {
|
|
update: XOR<UserUpdateWithoutChanceTransactionsInput, UserUncheckedUpdateWithoutChanceTransactionsInput>
|
|
create: XOR<UserCreateWithoutChanceTransactionsInput, UserUncheckedCreateWithoutChanceTransactionsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutChanceTransactionsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutChanceTransactionsInput, UserUncheckedUpdateWithoutChanceTransactionsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutChanceTransactionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutChanceTransactionsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUncheckedUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type CampaignUpsertWithoutChanceTxnsInput = {
|
|
update: XOR<CampaignUpdateWithoutChanceTxnsInput, CampaignUncheckedUpdateWithoutChanceTxnsInput>
|
|
create: XOR<CampaignCreateWithoutChanceTxnsInput, CampaignUncheckedCreateWithoutChanceTxnsInput>
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
export type CampaignUpdateToOneWithWhereWithoutChanceTxnsInput = {
|
|
where?: CampaignWhereInput
|
|
data: XOR<CampaignUpdateWithoutChanceTxnsInput, CampaignUncheckedUpdateWithoutChanceTxnsInput>
|
|
}
|
|
|
|
export type CampaignUpdateWithoutChanceTxnsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateWithoutChanceTxnsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type AdminUpsertWithoutChanceTxnsInput = {
|
|
update: XOR<AdminUpdateWithoutChanceTxnsInput, AdminUncheckedUpdateWithoutChanceTxnsInput>
|
|
create: XOR<AdminCreateWithoutChanceTxnsInput, AdminUncheckedCreateWithoutChanceTxnsInput>
|
|
where?: AdminWhereInput
|
|
}
|
|
|
|
export type AdminUpdateToOneWithWhereWithoutChanceTxnsInput = {
|
|
where?: AdminWhereInput
|
|
data: XOR<AdminUpdateWithoutChanceTxnsInput, AdminUncheckedUpdateWithoutChanceTxnsInput>
|
|
}
|
|
|
|
export type AdminUpdateWithoutChanceTxnsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
auditLogs?: AdminLogUpdateManyWithoutAdminNestedInput
|
|
}
|
|
|
|
export type AdminUncheckedUpdateWithoutChanceTxnsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
auditLogs?: AdminLogUncheckedUpdateManyWithoutAdminNestedInput
|
|
}
|
|
|
|
export type UserCreateWithoutSpinsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutSpinsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionUncheckedCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeUncheckedCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutSpinsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutSpinsInput, UserUncheckedCreateWithoutSpinsInput>
|
|
}
|
|
|
|
export type CampaignCreateWithoutSpinsInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUncheckedCreateWithoutSpinsInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCampaignInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignCreateOrConnectWithoutSpinsInput = {
|
|
where: CampaignWhereUniqueInput
|
|
create: XOR<CampaignCreateWithoutSpinsInput, CampaignUncheckedCreateWithoutSpinsInput>
|
|
}
|
|
|
|
export type PrizeCreateWithoutSpinsInput = {
|
|
id?: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
campaign: CampaignCreateNestedOneWithoutPrizesInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeUncheckedCreateWithoutSpinsInput = {
|
|
id?: string
|
|
campaignId: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeCreateOrConnectWithoutSpinsInput = {
|
|
where: PrizeWhereUniqueInput
|
|
create: XOR<PrizeCreateWithoutSpinsInput, PrizeUncheckedCreateWithoutSpinsInput>
|
|
}
|
|
|
|
export type UserPrizeCreateWithoutSpinInput = {
|
|
id?: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
user: UserCreateNestedOneWithoutUserPrizesInput
|
|
campaign: CampaignCreateNestedOneWithoutUserPrizesInput
|
|
prize: PrizeCreateNestedOneWithoutUserPrizesInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedCreateWithoutSpinInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type UserPrizeCreateOrConnectWithoutSpinInput = {
|
|
where: UserPrizeWhereUniqueInput
|
|
create: XOR<UserPrizeCreateWithoutSpinInput, UserPrizeUncheckedCreateWithoutSpinInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutSpinsInput = {
|
|
update: XOR<UserUpdateWithoutSpinsInput, UserUncheckedUpdateWithoutSpinsInput>
|
|
create: XOR<UserCreateWithoutSpinsInput, UserUncheckedCreateWithoutSpinsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutSpinsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutSpinsInput, UserUncheckedUpdateWithoutSpinsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutSpinsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutSpinsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUncheckedUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type CampaignUpsertWithoutSpinsInput = {
|
|
update: XOR<CampaignUpdateWithoutSpinsInput, CampaignUncheckedUpdateWithoutSpinsInput>
|
|
create: XOR<CampaignCreateWithoutSpinsInput, CampaignUncheckedCreateWithoutSpinsInput>
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
export type CampaignUpdateToOneWithWhereWithoutSpinsInput = {
|
|
where?: CampaignWhereInput
|
|
data: XOR<CampaignUpdateWithoutSpinsInput, CampaignUncheckedUpdateWithoutSpinsInput>
|
|
}
|
|
|
|
export type CampaignUpdateWithoutSpinsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateWithoutSpinsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type PrizeUpsertWithoutSpinsInput = {
|
|
update: XOR<PrizeUpdateWithoutSpinsInput, PrizeUncheckedUpdateWithoutSpinsInput>
|
|
create: XOR<PrizeCreateWithoutSpinsInput, PrizeUncheckedCreateWithoutSpinsInput>
|
|
where?: PrizeWhereInput
|
|
}
|
|
|
|
export type PrizeUpdateToOneWithWhereWithoutSpinsInput = {
|
|
where?: PrizeWhereInput
|
|
data: XOR<PrizeUpdateWithoutSpinsInput, PrizeUncheckedUpdateWithoutSpinsInput>
|
|
}
|
|
|
|
export type PrizeUpdateWithoutSpinsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
campaign?: CampaignUpdateOneRequiredWithoutPrizesNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateWithoutSpinsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type UserPrizeUpsertWithoutSpinInput = {
|
|
update: XOR<UserPrizeUpdateWithoutSpinInput, UserPrizeUncheckedUpdateWithoutSpinInput>
|
|
create: XOR<UserPrizeCreateWithoutSpinInput, UserPrizeUncheckedCreateWithoutSpinInput>
|
|
where?: UserPrizeWhereInput
|
|
}
|
|
|
|
export type UserPrizeUpdateToOneWithWhereWithoutSpinInput = {
|
|
where?: UserPrizeWhereInput
|
|
data: XOR<UserPrizeUpdateWithoutSpinInput, UserPrizeUncheckedUpdateWithoutSpinInput>
|
|
}
|
|
|
|
export type UserPrizeUpdateWithoutSpinInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
user?: UserUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
prize?: PrizeUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateWithoutSpinInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type UserCreateWithoutUserPrizesInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionCreateNestedManyWithoutUserInput
|
|
spins?: SpinCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutUserPrizesInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionUncheckedCreateNestedManyWithoutUserInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeUncheckedCreateNestedManyWithoutUserInput
|
|
smsLogs?: SmsLogUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutUserPrizesInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutUserPrizesInput, UserUncheckedCreateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type CampaignCreateWithoutUserPrizesInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignUncheckedCreateWithoutUserPrizesInput = {
|
|
id?: string
|
|
title: string
|
|
slug: string
|
|
description?: string | null
|
|
image?: string | null
|
|
banner?: string | null
|
|
logo?: string | null
|
|
startAt: Date | string
|
|
endAt: Date | string
|
|
status?: $Enums.CampaignStatus
|
|
defaultChances?: number
|
|
rules?: string | null
|
|
ctaText?: string | null
|
|
wheelDesign?: $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
prizes?: PrizeUncheckedCreateNestedManyWithoutCampaignInput
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutCampaignInput
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCampaignInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutCampaignInput
|
|
}
|
|
|
|
export type CampaignCreateOrConnectWithoutUserPrizesInput = {
|
|
where: CampaignWhereUniqueInput
|
|
create: XOR<CampaignCreateWithoutUserPrizesInput, CampaignUncheckedCreateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type PrizeCreateWithoutUserPrizesInput = {
|
|
id?: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
campaign: CampaignCreateNestedOneWithoutPrizesInput
|
|
spins?: SpinCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeUncheckedCreateWithoutUserPrizesInput = {
|
|
id?: string
|
|
campaignId: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
spins?: SpinUncheckedCreateNestedManyWithoutPrizeInput
|
|
}
|
|
|
|
export type PrizeCreateOrConnectWithoutUserPrizesInput = {
|
|
where: PrizeWhereUniqueInput
|
|
create: XOR<PrizeCreateWithoutUserPrizesInput, PrizeUncheckedCreateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type SpinCreateWithoutUserPrizeInput = {
|
|
id?: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
user: UserCreateNestedOneWithoutSpinsInput
|
|
campaign: CampaignCreateNestedOneWithoutSpinsInput
|
|
prize?: PrizeCreateNestedOneWithoutSpinsInput
|
|
}
|
|
|
|
export type SpinUncheckedCreateWithoutUserPrizeInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SpinCreateOrConnectWithoutUserPrizeInput = {
|
|
where: SpinWhereUniqueInput
|
|
create: XOR<SpinCreateWithoutUserPrizeInput, SpinUncheckedCreateWithoutUserPrizeInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutUserPrizesInput = {
|
|
update: XOR<UserUpdateWithoutUserPrizesInput, UserUncheckedUpdateWithoutUserPrizesInput>
|
|
create: XOR<UserCreateWithoutUserPrizesInput, UserUncheckedCreateWithoutUserPrizesInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutUserPrizesInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutUserPrizesInput, UserUncheckedUpdateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutUserPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutUserPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUncheckedUpdateManyWithoutUserNestedInput
|
|
smsLogs?: SmsLogUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type CampaignUpsertWithoutUserPrizesInput = {
|
|
update: XOR<CampaignUpdateWithoutUserPrizesInput, CampaignUncheckedUpdateWithoutUserPrizesInput>
|
|
create: XOR<CampaignCreateWithoutUserPrizesInput, CampaignUncheckedCreateWithoutUserPrizesInput>
|
|
where?: CampaignWhereInput
|
|
}
|
|
|
|
export type CampaignUpdateToOneWithWhereWithoutUserPrizesInput = {
|
|
where?: CampaignWhereInput
|
|
data: XOR<CampaignUpdateWithoutUserPrizesInput, CampaignUncheckedUpdateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type CampaignUpdateWithoutUserPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type CampaignUncheckedUpdateWithoutUserPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
slug?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
banner?: NullableStringFieldUpdateOperationsInput | string | null
|
|
logo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
startAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
status?: EnumCampaignStatusFieldUpdateOperationsInput | $Enums.CampaignStatus
|
|
defaultChances?: IntFieldUpdateOperationsInput | number
|
|
rules?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ctaText?: NullableStringFieldUpdateOperationsInput | string | null
|
|
wheelDesign?: EnumWheelDesignFieldUpdateOperationsInput | $Enums.WheelDesign
|
|
settings?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
prizes?: PrizeUncheckedUpdateManyWithoutCampaignNestedInput
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutCampaignNestedInput
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCampaignNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutCampaignNestedInput
|
|
}
|
|
|
|
export type PrizeUpsertWithoutUserPrizesInput = {
|
|
update: XOR<PrizeUpdateWithoutUserPrizesInput, PrizeUncheckedUpdateWithoutUserPrizesInput>
|
|
create: XOR<PrizeCreateWithoutUserPrizesInput, PrizeUncheckedCreateWithoutUserPrizesInput>
|
|
where?: PrizeWhereInput
|
|
}
|
|
|
|
export type PrizeUpdateToOneWithWhereWithoutUserPrizesInput = {
|
|
where?: PrizeWhereInput
|
|
data: XOR<PrizeUpdateWithoutUserPrizesInput, PrizeUncheckedUpdateWithoutUserPrizesInput>
|
|
}
|
|
|
|
export type PrizeUpdateWithoutUserPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
campaign?: CampaignUpdateOneRequiredWithoutPrizesNestedInput
|
|
spins?: SpinUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateWithoutUserPrizesInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
spins?: SpinUncheckedUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type SpinUpsertWithoutUserPrizeInput = {
|
|
update: XOR<SpinUpdateWithoutUserPrizeInput, SpinUncheckedUpdateWithoutUserPrizeInput>
|
|
create: XOR<SpinCreateWithoutUserPrizeInput, SpinUncheckedCreateWithoutUserPrizeInput>
|
|
where?: SpinWhereInput
|
|
}
|
|
|
|
export type SpinUpdateToOneWithWhereWithoutUserPrizeInput = {
|
|
where?: SpinWhereInput
|
|
data: XOR<SpinUpdateWithoutUserPrizeInput, SpinUncheckedUpdateWithoutUserPrizeInput>
|
|
}
|
|
|
|
export type SpinUpdateWithoutUserPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutSpinsNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutSpinsNestedInput
|
|
prize?: PrizeUpdateOneWithoutSpinsNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateWithoutUserPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCreateWithoutSmsLogsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionCreateNestedManyWithoutUserInput
|
|
spins?: SpinCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserUncheckedCreateWithoutSmsLogsInput = {
|
|
id?: string
|
|
mobile: string
|
|
name?: string | null
|
|
status?: $Enums.UserStatus
|
|
lastLoginAt?: Date | string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
userCampaigns?: UserCampaignUncheckedCreateNestedManyWithoutUserInput
|
|
chanceTransactions?: ChanceTransactionUncheckedCreateNestedManyWithoutUserInput
|
|
spins?: SpinUncheckedCreateNestedManyWithoutUserInput
|
|
userPrizes?: UserPrizeUncheckedCreateNestedManyWithoutUserInput
|
|
otpCodes?: OtpCodeUncheckedCreateNestedManyWithoutUserInput
|
|
}
|
|
|
|
export type UserCreateOrConnectWithoutSmsLogsInput = {
|
|
where: UserWhereUniqueInput
|
|
create: XOR<UserCreateWithoutSmsLogsInput, UserUncheckedCreateWithoutSmsLogsInput>
|
|
}
|
|
|
|
export type UserUpsertWithoutSmsLogsInput = {
|
|
update: XOR<UserUpdateWithoutSmsLogsInput, UserUncheckedUpdateWithoutSmsLogsInput>
|
|
create: XOR<UserCreateWithoutSmsLogsInput, UserUncheckedCreateWithoutSmsLogsInput>
|
|
where?: UserWhereInput
|
|
}
|
|
|
|
export type UserUpdateToOneWithWhereWithoutSmsLogsInput = {
|
|
where?: UserWhereInput
|
|
data: XOR<UserUpdateWithoutSmsLogsInput, UserUncheckedUpdateWithoutSmsLogsInput>
|
|
}
|
|
|
|
export type UserUpdateWithoutSmsLogsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type UserUncheckedUpdateWithoutSmsLogsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserStatusFieldUpdateOperationsInput | $Enums.UserStatus
|
|
lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userCampaigns?: UserCampaignUncheckedUpdateManyWithoutUserNestedInput
|
|
chanceTransactions?: ChanceTransactionUncheckedUpdateManyWithoutUserNestedInput
|
|
spins?: SpinUncheckedUpdateManyWithoutUserNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutUserNestedInput
|
|
otpCodes?: OtpCodeUncheckedUpdateManyWithoutUserNestedInput
|
|
}
|
|
|
|
export type AdminCreateWithoutAuditLogsInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
chanceTxns?: ChanceTransactionCreateNestedManyWithoutCreatedByInput
|
|
}
|
|
|
|
export type AdminUncheckedCreateWithoutAuditLogsInput = {
|
|
id?: string
|
|
name: string
|
|
mobile: string
|
|
email: string
|
|
passwordHash: string
|
|
role?: $Enums.AdminRole
|
|
status?: $Enums.AdminStatus
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
chanceTxns?: ChanceTransactionUncheckedCreateNestedManyWithoutCreatedByInput
|
|
}
|
|
|
|
export type AdminCreateOrConnectWithoutAuditLogsInput = {
|
|
where: AdminWhereUniqueInput
|
|
create: XOR<AdminCreateWithoutAuditLogsInput, AdminUncheckedCreateWithoutAuditLogsInput>
|
|
}
|
|
|
|
export type AdminUpsertWithoutAuditLogsInput = {
|
|
update: XOR<AdminUpdateWithoutAuditLogsInput, AdminUncheckedUpdateWithoutAuditLogsInput>
|
|
create: XOR<AdminCreateWithoutAuditLogsInput, AdminUncheckedCreateWithoutAuditLogsInput>
|
|
where?: AdminWhereInput
|
|
}
|
|
|
|
export type AdminUpdateToOneWithWhereWithoutAuditLogsInput = {
|
|
where?: AdminWhereInput
|
|
data: XOR<AdminUpdateWithoutAuditLogsInput, AdminUncheckedUpdateWithoutAuditLogsInput>
|
|
}
|
|
|
|
export type AdminUpdateWithoutAuditLogsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
chanceTxns?: ChanceTransactionUpdateManyWithoutCreatedByNestedInput
|
|
}
|
|
|
|
export type AdminUncheckedUpdateWithoutAuditLogsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
email?: StringFieldUpdateOperationsInput | string
|
|
passwordHash?: StringFieldUpdateOperationsInput | string
|
|
role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
|
|
status?: EnumAdminStatusFieldUpdateOperationsInput | $Enums.AdminStatus
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
chanceTxns?: ChanceTransactionUncheckedUpdateManyWithoutCreatedByNestedInput
|
|
}
|
|
|
|
export type AdminLogCreateManyAdminInput = {
|
|
id?: string
|
|
action: string
|
|
entityType: string
|
|
entityId: string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyCreatedByInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type AdminLogUpdateWithoutAdminInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AdminLogUncheckedUpdateWithoutAdminInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AdminLogUncheckedUpdateManyWithoutAdminInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
action?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
oldValue?: NullableJsonNullValueInput | InputJsonValue
|
|
newValue?: NullableJsonNullValueInput | InputJsonValue
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpdateWithoutCreatedByInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutChanceTransactionsNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutChanceTxnsNestedInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateWithoutCreatedByInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyWithoutCreatedByInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateManyUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdById?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SpinCreateManyUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type UserPrizeCreateManyUserInput = {
|
|
id?: string
|
|
campaignId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type OtpCodeCreateManyUserInput = {
|
|
id?: string
|
|
mobile: string
|
|
code: string
|
|
attempts?: number
|
|
consumed?: boolean
|
|
expiresAt: Date | string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SmsLogCreateManyUserInput = {
|
|
id?: string
|
|
mobile: string
|
|
type: $Enums.SmsType
|
|
message: string
|
|
provider?: string
|
|
status?: $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type UserCampaignUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
campaign?: CampaignUpdateOneRequiredWithoutUserCampaignsNestedInput
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
campaign?: CampaignUpdateOneRequiredWithoutChanceTxnsNestedInput
|
|
createdBy?: AdminUpdateOneWithoutChanceTxnsNestedInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdById?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdById?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SpinUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
campaign?: CampaignUpdateOneRequiredWithoutSpinsNestedInput
|
|
prize?: PrizeUpdateOneWithoutSpinsNestedInput
|
|
userPrize?: UserPrizeUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userPrize?: UserPrizeUncheckedUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserPrizeUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
campaign?: CampaignUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
prize?: PrizeUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
spin?: SpinUpdateOneRequiredWithoutUserPrizeNestedInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type OtpCodeUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type OtpCodeUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type OtpCodeUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
code?: StringFieldUpdateOperationsInput | string
|
|
attempts?: IntFieldUpdateOperationsInput | number
|
|
consumed?: BoolFieldUpdateOperationsInput | boolean
|
|
expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SmsLogUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SmsLogUncheckedUpdateWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SmsLogUncheckedUpdateManyWithoutUserInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
mobile?: StringFieldUpdateOperationsInput | string
|
|
type?: EnumSmsTypeFieldUpdateOperationsInput | $Enums.SmsType
|
|
message?: StringFieldUpdateOperationsInput | string
|
|
provider?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSmsStatusFieldUpdateOperationsInput | $Enums.SmsStatus
|
|
providerResponse?: NullableJsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PrizeCreateManyCampaignInput = {
|
|
id?: string
|
|
title: string
|
|
description?: string | null
|
|
image?: string | null
|
|
type: $Enums.PrizeType
|
|
stockType: $Enums.StockType
|
|
initialStock?: number | null
|
|
remainingStock?: number | null
|
|
weight: number
|
|
status?: $Enums.PrizeStatus
|
|
sortOrder?: number
|
|
segmentColor: string
|
|
expiresAt?: Date | string | null
|
|
smsTemplate?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UserCampaignCreateManyCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
totalChances?: number
|
|
usedChances?: number
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type ChanceTransactionCreateManyCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
amount: number
|
|
type: $Enums.ChanceTxnType
|
|
referenceType?: string | null
|
|
referenceId?: string | null
|
|
description?: string | null
|
|
createdById?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type SpinCreateManyCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
prizeId?: string | null
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type UserPrizeCreateManyCampaignInput = {
|
|
id?: string
|
|
userId: string
|
|
prizeId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type PrizeUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
spins?: SpinUpdateManyWithoutPrizeNestedInput
|
|
userPrizes?: UserPrizeUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
spins?: SpinUncheckedUpdateManyWithoutPrizeNestedInput
|
|
userPrizes?: UserPrizeUncheckedUpdateManyWithoutPrizeNestedInput
|
|
}
|
|
|
|
export type PrizeUncheckedUpdateManyWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
title?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
image?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: EnumPrizeTypeFieldUpdateOperationsInput | $Enums.PrizeType
|
|
stockType?: EnumStockTypeFieldUpdateOperationsInput | $Enums.StockType
|
|
initialStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
remainingStock?: NullableIntFieldUpdateOperationsInput | number | null
|
|
weight?: IntFieldUpdateOperationsInput | number
|
|
status?: EnumPrizeStatusFieldUpdateOperationsInput | $Enums.PrizeStatus
|
|
sortOrder?: IntFieldUpdateOperationsInput | number
|
|
segmentColor?: StringFieldUpdateOperationsInput | string
|
|
expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
smsTemplate?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutUserCampaignsNestedInput
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserCampaignUncheckedUpdateManyWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
totalChances?: IntFieldUpdateOperationsInput | number
|
|
usedChances?: IntFieldUpdateOperationsInput | number
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutChanceTransactionsNestedInput
|
|
createdBy?: AdminUpdateOneWithoutChanceTxnsNestedInput
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdById?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type ChanceTransactionUncheckedUpdateManyWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
amount?: IntFieldUpdateOperationsInput | number
|
|
type?: EnumChanceTxnTypeFieldUpdateOperationsInput | $Enums.ChanceTxnType
|
|
referenceType?: NullableStringFieldUpdateOperationsInput | string | null
|
|
referenceId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdById?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type SpinUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutSpinsNestedInput
|
|
prize?: PrizeUpdateOneWithoutSpinsNestedInput
|
|
userPrize?: UserPrizeUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userPrize?: UserPrizeUncheckedUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserPrizeUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
user?: UserUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
prize?: PrizeUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
spin?: SpinUpdateOneRequiredWithoutUserPrizeNestedInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyWithoutCampaignInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
prizeId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type SpinCreateManyPrizeInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
status?: $Enums.SpinStatus
|
|
idempotencyKey: string
|
|
ip?: string | null
|
|
userAgent?: string | null
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type UserPrizeCreateManyPrizeInput = {
|
|
id?: string
|
|
userId: string
|
|
campaignId: string
|
|
spinId: string
|
|
code?: string | null
|
|
status?: $Enums.UserPrizeStatus
|
|
wonAt?: Date | string
|
|
redeemedAt?: Date | string | null
|
|
}
|
|
|
|
export type SpinUpdateWithoutPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
user?: UserUpdateOneRequiredWithoutSpinsNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutSpinsNestedInput
|
|
userPrize?: UserPrizeUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateWithoutPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
userPrize?: UserPrizeUncheckedUpdateOneWithoutSpinNestedInput
|
|
}
|
|
|
|
export type SpinUncheckedUpdateManyWithoutPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
status?: EnumSpinStatusFieldUpdateOperationsInput | $Enums.SpinStatus
|
|
idempotencyKey?: StringFieldUpdateOperationsInput | string
|
|
ip?: NullableStringFieldUpdateOperationsInput | string | null
|
|
userAgent?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UserPrizeUpdateWithoutPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
user?: UserUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
campaign?: CampaignUpdateOneRequiredWithoutUserPrizesNestedInput
|
|
spin?: SpinUpdateOneRequiredWithoutUserPrizeNestedInput
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateWithoutPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
export type UserPrizeUncheckedUpdateManyWithoutPrizeInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
userId?: StringFieldUpdateOperationsInput | string
|
|
campaignId?: StringFieldUpdateOperationsInput | string
|
|
spinId?: StringFieldUpdateOperationsInput | string
|
|
code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
status?: EnumUserPrizeStatusFieldUpdateOperationsInput | $Enums.UserPrizeStatus
|
|
wonAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
redeemedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Aliases for legacy arg types
|
|
*/
|
|
/**
|
|
* @deprecated Use AdminCountOutputTypeDefaultArgs instead
|
|
*/
|
|
export type AdminCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AdminCountOutputTypeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use UserCountOutputTypeDefaultArgs instead
|
|
*/
|
|
export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use CampaignCountOutputTypeDefaultArgs instead
|
|
*/
|
|
export type CampaignCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CampaignCountOutputTypeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use PrizeCountOutputTypeDefaultArgs instead
|
|
*/
|
|
export type PrizeCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PrizeCountOutputTypeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use AdminDefaultArgs instead
|
|
*/
|
|
export type AdminArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AdminDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use UserDefaultArgs instead
|
|
*/
|
|
export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use OtpCodeDefaultArgs instead
|
|
*/
|
|
export type OtpCodeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OtpCodeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use CampaignDefaultArgs instead
|
|
*/
|
|
export type CampaignArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CampaignDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use PrizeDefaultArgs instead
|
|
*/
|
|
export type PrizeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PrizeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use UserCampaignDefaultArgs instead
|
|
*/
|
|
export type UserCampaignArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCampaignDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use ChanceTransactionDefaultArgs instead
|
|
*/
|
|
export type ChanceTransactionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChanceTransactionDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use SpinDefaultArgs instead
|
|
*/
|
|
export type SpinArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SpinDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use UserPrizeDefaultArgs instead
|
|
*/
|
|
export type UserPrizeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserPrizeDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use SmsLogDefaultArgs instead
|
|
*/
|
|
export type SmsLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SmsLogDefaultArgs<ExtArgs>
|
|
/**
|
|
* @deprecated Use AdminLogDefaultArgs instead
|
|
*/
|
|
export type AdminLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AdminLogDefaultArgs<ExtArgs>
|
|
|
|
/**
|
|
* Batch Payload for updateMany & deleteMany & createMany
|
|
*/
|
|
|
|
export type BatchPayload = {
|
|
count: number
|
|
}
|
|
|
|
/**
|
|
* DMMF
|
|
*/
|
|
export const dmmf: runtime.BaseDMMF
|
|
} |