/home/techb158/balavpn.abdallabala.com/node_modules/.prisma/client
Edit: /home/techb158/balavpn.abdallabala.com/node_modules/.prisma/client/index.d.ts (1836090B)
/**
* 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
= $Public.PrismaPromise
/**
* Model Organization
*
*/
export type Organization = $Result.DefaultSelection
/**
* Model Workspace
*
*/
export type Workspace = $Result.DefaultSelection
/**
* Model User
*
*/
export type User = $Result.DefaultSelection
/**
* Model Session
*
*/
export type Session = $Result.DefaultSelection
/**
* Model Role
*
*/
export type Role = $Result.DefaultSelection
/**
* Model Membership
*
*/
export type Membership = $Result.DefaultSelection
/**
* Model Invitation
*
*/
export type Invitation = $Result.DefaultSelection
/**
* Model Subscription
*
*/
export type Subscription = $Result.DefaultSelection
/**
* Model Project
*
*/
export type Project = $Result.DefaultSelection
/**
* Model LifecyclePhase
*
*/
export type LifecyclePhase = $Result.DefaultSelection
/**
* Model Risk
*
*/
export type Risk = $Result.DefaultSelection
/**
* Model Mitigation
*
*/
export type Mitigation = $Result.DefaultSelection
/**
* Model Evidence
*
*/
export type Evidence = $Result.DefaultSelection
/**
* Model Indicator
*
*/
export type Indicator = $Result.DefaultSelection
/**
* Model Experiment
*
*/
export type Experiment = $Result.DefaultSelection
/**
* Model ModelMetric
*
*/
export type ModelMetric = $Result.DefaultSelection
/**
* Model GateEvaluation
*
*/
export type GateEvaluation = $Result.DefaultSelection
/**
* Model GateCriterion
*
*/
export type GateCriterion = $Result.DefaultSelection
/**
* Model GateDecision
*
*/
export type GateDecision = $Result.DefaultSelection
/**
* Model Integration
*
*/
export type Integration = $Result.DefaultSelection
/**
* Model ExternalWorkItemMapping
*
*/
export type ExternalWorkItemMapping = $Result.DefaultSelection
/**
* Model IntegrationSyncRun
*
*/
export type IntegrationSyncRun = $Result.DefaultSelection
/**
* Model OAuthToken
*
*/
export type OAuthToken = $Result.DefaultSelection
/**
* Model ReportExport
*
*/
export type ReportExport = $Result.DefaultSelection
/**
* Model AuditEvent
*
*/
export type AuditEvent = $Result.DefaultSelection
/**
* Model UsageEvent
*
*/
export type UsageEvent = $Result.DefaultSelection
/**
* Enums
*/
export namespace $Enums {
export const OrganizationStatus: {
TRIAL: 'TRIAL',
ACTIVE: 'ACTIVE',
SUSPENDED: 'SUSPENDED',
CANCELED: 'CANCELED'
};
export type OrganizationStatus = (typeof OrganizationStatus)[keyof typeof OrganizationStatus]
export const WorkspaceType: {
B2B_TEAM: 'B2B_TEAM',
CONSULTANT_CLIENT: 'CONSULTANT_CLIENT',
ENTERPRISE: 'ENTERPRISE'
};
export type WorkspaceType = (typeof WorkspaceType)[keyof typeof WorkspaceType]
export const MembershipStatus: {
INVITED: 'INVITED',
ACTIVE: 'ACTIVE',
DISABLED: 'DISABLED'
};
export type MembershipStatus = (typeof MembershipStatus)[keyof typeof MembershipStatus]
export const SubscriptionSource: {
MANUAL: 'MANUAL',
STRIPE: 'STRIPE'
};
export type SubscriptionSource = (typeof SubscriptionSource)[keyof typeof SubscriptionSource]
export const SubscriptionStatus: {
TRIALING: 'TRIALING',
ACTIVE: 'ACTIVE',
PAST_DUE: 'PAST_DUE',
CANCELED: 'CANCELED',
SUSPENDED: 'SUSPENDED'
};
export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus]
export const RiskStatus: {
OPEN: 'OPEN',
IN_MITIGATION: 'IN_MITIGATION',
ACCEPTED: 'ACCEPTED',
CLOSED: 'CLOSED'
};
export type RiskStatus = (typeof RiskStatus)[keyof typeof RiskStatus]
export const ApprovalStatus: {
PENDING: 'PENDING',
APPROVED: 'APPROVED',
REJECTED: 'REJECTED',
ACCEPTED: 'ACCEPTED'
};
export type ApprovalStatus = (typeof ApprovalStatus)[keyof typeof ApprovalStatus]
export const MitigationStatus: {
NOT_STARTED: 'NOT_STARTED',
IN_PROGRESS: 'IN_PROGRESS',
DONE: 'DONE',
REJECTED: 'REJECTED'
};
export type MitigationStatus = (typeof MitigationStatus)[keyof typeof MitigationStatus]
export const GateStatus: {
READY: 'READY',
WARNING: 'WARNING',
BLOCKED: 'BLOCKED'
};
export type GateStatus = (typeof GateStatus)[keyof typeof GateStatus]
export const GateDecisionValue: {
APPROVED: 'APPROVED',
REJECTED: 'REJECTED',
ACCEPTED: 'ACCEPTED',
NEEDS_CHANGES: 'NEEDS_CHANGES'
};
export type GateDecisionValue = (typeof GateDecisionValue)[keyof typeof GateDecisionValue]
export const IntegrationProvider: {
TRELLO: 'TRELLO',
JIRA: 'JIRA',
ASANA: 'ASANA',
MICROSOFT_PLANNER: 'MICROSOFT_PLANNER'
};
export type IntegrationProvider = (typeof IntegrationProvider)[keyof typeof IntegrationProvider]
export const IntegrationStatus: {
CONNECTED: 'CONNECTED',
NEEDS_CONFIGURATION: 'NEEDS_CONFIGURATION',
DISABLED: 'DISABLED'
};
export type IntegrationStatus = (typeof IntegrationStatus)[keyof typeof IntegrationStatus]
}
export type OrganizationStatus = $Enums.OrganizationStatus
export const OrganizationStatus: typeof $Enums.OrganizationStatus
export type WorkspaceType = $Enums.WorkspaceType
export const WorkspaceType: typeof $Enums.WorkspaceType
export type MembershipStatus = $Enums.MembershipStatus
export const MembershipStatus: typeof $Enums.MembershipStatus
export type SubscriptionSource = $Enums.SubscriptionSource
export const SubscriptionSource: typeof $Enums.SubscriptionSource
export type SubscriptionStatus = $Enums.SubscriptionStatus
export const SubscriptionStatus: typeof $Enums.SubscriptionStatus
export type RiskStatus = $Enums.RiskStatus
export const RiskStatus: typeof $Enums.RiskStatus
export type ApprovalStatus = $Enums.ApprovalStatus
export const ApprovalStatus: typeof $Enums.ApprovalStatus
export type MitigationStatus = $Enums.MitigationStatus
export const MitigationStatus: typeof $Enums.MitigationStatus
export type GateStatus = $Enums.GateStatus
export const GateStatus: typeof $Enums.GateStatus
export type GateDecisionValue = $Enums.GateDecisionValue
export const GateDecisionValue: typeof $Enums.GateDecisionValue
export type IntegrationProvider = $Enums.IntegrationProvider
export const IntegrationProvider: typeof $Enums.IntegrationProvider
export type IntegrationStatus = $Enums.IntegrationStatus
export const IntegrationStatus: typeof $Enums.IntegrationStatus
/**
* ## Prisma Client ʲˢ
*
* Type-safe database client for TypeScript & Node.js
* @example
* ```
* const prisma = new PrismaClient()
* // Fetch zero or more Organizations
* const organizations = await prisma.organization.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.GetEvents : never : never,
ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
> {
[K: symbol]: { types: Prisma.TypeMap['other'] }
/**
* ## Prisma Client ʲˢ
*
* Type-safe database client for TypeScript & Node.js
* @example
* ```
* const prisma = new PrismaClient()
* // Fetch zero or more Organizations
* const organizations = await prisma.organization.findMany()
* ```
*
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
*/
constructor(optionsArg ?: Prisma.Subset);
$on(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void;
/**
* Connect with the database
*/
$connect(): $Utils.JsPromise;
/**
* Disconnect from the database
*/
$disconnect(): $Utils.JsPromise;
/**
* 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(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise;
/**
* 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(query: string, ...values: any[]): Prisma.PrismaPromise;
/**
* 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(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise;
/**
* 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(query: string, ...values: any[]): Prisma.PrismaPromise;
/**
* 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[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise>
$transaction(fn: (prisma: Omit) => $Utils.JsPromise, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise
$extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs>
/**
* `prisma.organization`: Exposes CRUD operations for the **Organization** model.
* Example usage:
* ```ts
* // Fetch zero or more Organizations
* const organizations = await prisma.organization.findMany()
* ```
*/
get organization(): Prisma.OrganizationDelegate;
/**
* `prisma.workspace`: Exposes CRUD operations for the **Workspace** model.
* Example usage:
* ```ts
* // Fetch zero or more Workspaces
* const workspaces = await prisma.workspace.findMany()
* ```
*/
get workspace(): Prisma.WorkspaceDelegate;
/**
* `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;
/**
* `prisma.session`: Exposes CRUD operations for the **Session** model.
* Example usage:
* ```ts
* // Fetch zero or more Sessions
* const sessions = await prisma.session.findMany()
* ```
*/
get session(): Prisma.SessionDelegate;
/**
* `prisma.role`: Exposes CRUD operations for the **Role** model.
* Example usage:
* ```ts
* // Fetch zero or more Roles
* const roles = await prisma.role.findMany()
* ```
*/
get role(): Prisma.RoleDelegate;
/**
* `prisma.membership`: Exposes CRUD operations for the **Membership** model.
* Example usage:
* ```ts
* // Fetch zero or more Memberships
* const memberships = await prisma.membership.findMany()
* ```
*/
get membership(): Prisma.MembershipDelegate;
/**
* `prisma.invitation`: Exposes CRUD operations for the **Invitation** model.
* Example usage:
* ```ts
* // Fetch zero or more Invitations
* const invitations = await prisma.invitation.findMany()
* ```
*/
get invitation(): Prisma.InvitationDelegate;
/**
* `prisma.subscription`: Exposes CRUD operations for the **Subscription** model.
* Example usage:
* ```ts
* // Fetch zero or more Subscriptions
* const subscriptions = await prisma.subscription.findMany()
* ```
*/
get subscription(): Prisma.SubscriptionDelegate;
/**
* `prisma.project`: Exposes CRUD operations for the **Project** model.
* Example usage:
* ```ts
* // Fetch zero or more Projects
* const projects = await prisma.project.findMany()
* ```
*/
get project(): Prisma.ProjectDelegate;
/**
* `prisma.lifecyclePhase`: Exposes CRUD operations for the **LifecyclePhase** model.
* Example usage:
* ```ts
* // Fetch zero or more LifecyclePhases
* const lifecyclePhases = await prisma.lifecyclePhase.findMany()
* ```
*/
get lifecyclePhase(): Prisma.LifecyclePhaseDelegate;
/**
* `prisma.risk`: Exposes CRUD operations for the **Risk** model.
* Example usage:
* ```ts
* // Fetch zero or more Risks
* const risks = await prisma.risk.findMany()
* ```
*/
get risk(): Prisma.RiskDelegate;
/**
* `prisma.mitigation`: Exposes CRUD operations for the **Mitigation** model.
* Example usage:
* ```ts
* // Fetch zero or more Mitigations
* const mitigations = await prisma.mitigation.findMany()
* ```
*/
get mitigation(): Prisma.MitigationDelegate;
/**
* `prisma.evidence`: Exposes CRUD operations for the **Evidence** model.
* Example usage:
* ```ts
* // Fetch zero or more Evidences
* const evidences = await prisma.evidence.findMany()
* ```
*/
get evidence(): Prisma.EvidenceDelegate;
/**
* `prisma.indicator`: Exposes CRUD operations for the **Indicator** model.
* Example usage:
* ```ts
* // Fetch zero or more Indicators
* const indicators = await prisma.indicator.findMany()
* ```
*/
get indicator(): Prisma.IndicatorDelegate;
/**
* `prisma.experiment`: Exposes CRUD operations for the **Experiment** model.
* Example usage:
* ```ts
* // Fetch zero or more Experiments
* const experiments = await prisma.experiment.findMany()
* ```
*/
get experiment(): Prisma.ExperimentDelegate;
/**
* `prisma.modelMetric`: Exposes CRUD operations for the **ModelMetric** model.
* Example usage:
* ```ts
* // Fetch zero or more ModelMetrics
* const modelMetrics = await prisma.modelMetric.findMany()
* ```
*/
get modelMetric(): Prisma.ModelMetricDelegate;
/**
* `prisma.gateEvaluation`: Exposes CRUD operations for the **GateEvaluation** model.
* Example usage:
* ```ts
* // Fetch zero or more GateEvaluations
* const gateEvaluations = await prisma.gateEvaluation.findMany()
* ```
*/
get gateEvaluation(): Prisma.GateEvaluationDelegate;
/**
* `prisma.gateCriterion`: Exposes CRUD operations for the **GateCriterion** model.
* Example usage:
* ```ts
* // Fetch zero or more GateCriteria
* const gateCriteria = await prisma.gateCriterion.findMany()
* ```
*/
get gateCriterion(): Prisma.GateCriterionDelegate;
/**
* `prisma.gateDecision`: Exposes CRUD operations for the **GateDecision** model.
* Example usage:
* ```ts
* // Fetch zero or more GateDecisions
* const gateDecisions = await prisma.gateDecision.findMany()
* ```
*/
get gateDecision(): Prisma.GateDecisionDelegate;
/**
* `prisma.integration`: Exposes CRUD operations for the **Integration** model.
* Example usage:
* ```ts
* // Fetch zero or more Integrations
* const integrations = await prisma.integration.findMany()
* ```
*/
get integration(): Prisma.IntegrationDelegate;
/**
* `prisma.externalWorkItemMapping`: Exposes CRUD operations for the **ExternalWorkItemMapping** model.
* Example usage:
* ```ts
* // Fetch zero or more ExternalWorkItemMappings
* const externalWorkItemMappings = await prisma.externalWorkItemMapping.findMany()
* ```
*/
get externalWorkItemMapping(): Prisma.ExternalWorkItemMappingDelegate;
/**
* `prisma.integrationSyncRun`: Exposes CRUD operations for the **IntegrationSyncRun** model.
* Example usage:
* ```ts
* // Fetch zero or more IntegrationSyncRuns
* const integrationSyncRuns = await prisma.integrationSyncRun.findMany()
* ```
*/
get integrationSyncRun(): Prisma.IntegrationSyncRunDelegate;
/**
* `prisma.oAuthToken`: Exposes CRUD operations for the **OAuthToken** model.
* Example usage:
* ```ts
* // Fetch zero or more OAuthTokens
* const oAuthTokens = await prisma.oAuthToken.findMany()
* ```
*/
get oAuthToken(): Prisma.OAuthTokenDelegate;
/**
* `prisma.reportExport`: Exposes CRUD operations for the **ReportExport** model.
* Example usage:
* ```ts
* // Fetch zero or more ReportExports
* const reportExports = await prisma.reportExport.findMany()
* ```
*/
get reportExport(): Prisma.ReportExportDelegate;
/**
* `prisma.auditEvent`: Exposes CRUD operations for the **AuditEvent** model.
* Example usage:
* ```ts
* // Fetch zero or more AuditEvents
* const auditEvents = await prisma.auditEvent.findMany()
* ```
*/
get auditEvent(): Prisma.AuditEventDelegate;
/**
* `prisma.usageEvent`: Exposes CRUD operations for the **UsageEvent** model.
* Example usage:
* ```ts
* // Fetch zero or more UsageEvents
* const usageEvents = await prisma.usageEvent.findMany()
* ```
*/
get usageEvent(): Prisma.UsageEventDelegate;
}
export namespace Prisma {
export import DMMF = runtime.DMMF
export type PrismaPromise = $Public.PrismaPromise
/**
* 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 = runtime.Metric
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 ? U : T;
/**
* Get the return type of a function which returns a Promise.
*/
export type PromiseReturnType $Utils.JsPromise> = PromiseType>
/**
* From T, pick a set of properties whose keys are in the union K
*/
type Prisma__Pick = {
[P in K]: T[P];
};
export type Enumerable = T | Array;
export type RequiredKeys = {
[K in keyof T]-?: {} extends Prisma__Pick ? never : K
}[keyof T]
export type TruthyKeys = keyof {
[K in keyof T as T[K] extends false | undefined | null ? never : K]: K
}
export type TrueKeys = TruthyKeys>>
/**
* Subset
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection
*/
export type Subset = {
[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 = {
[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 = {
[key in keyof T]: key extends keyof U ? T[key] : never
} &
K
type Without = { [P in Exclude]?: 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 extends object ?
U extends object ?
(Without & U) | (Without & T)
: U : T
/**
* Is T a Record?
*/
type IsObject = T extends Array
? 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 Array ? U : T
/**
* From ts-toolbelt
*/
type __Either = Omit &
{
// Merge all but K
[P in K]: Prisma__Pick // With K possibilities
}[K]
type EitherStrict = Strict<__Either>
type EitherLoose = ComputeRaw<__Either>
type _Either<
O extends object,
K extends Key,
strict extends Boolean
> = {
1: EitherStrict
0: EitherLoose
}[strict]
type Either<
O extends object,
K extends Key,
strict extends Boolean = 1
> = O extends unknown ? _Either : never
export type Union = any
type PatchUndefined = {
[K in keyof O]: O[K] extends undefined ? At : O[K]
} & {}
/** Helper Types for "Merge" **/
export type IntersectOf = (
U extends unknown ? (k: U) => void : never
) extends (k: infer I) => void
? I
: never
export type Overwrite = {
[K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
} & {};
type _Merge = IntersectOf;
}>>;
type Key = string | number | symbol;
type AtBasic = K extends keyof O ? O[K] : never;
type AtStrict = O[K & keyof O];
type AtLoose = O extends unknown ? AtStrict : never;
export type At = {
1: AtStrict;
0: AtLoose;
}[strict];
export type ComputeRaw = A extends Function ? A : {
[K in keyof A]: A[K];
} & {};
export type OptionalFlat = {
[K in keyof O]?: O[K];
} & {};
type _Record = {
[P in K]: T;
};
// cause typescript not to expand types and preserve names
type NoExpand = T extends unknown ? T : never;
// this type assumes the passed object is entirely optional
type AtLeast = 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 extends unknown ? U & OptionalFlat<_Record, keyof U>, never>> : never;
export type Strict = ComputeRaw<_Strict>;
/** End Helper Types for "Merge" **/
export type Merge = ComputeRaw<_Merge>>;
/**
A [[Boolean]]
*/
export type Boolean = True | False
// /**
// 1
// */
export type True = 1
/**
0
*/
export type False = 0
export type Not = {
0: 1
1: 0
}[B]
export type Extends = [A1] extends [never]
? 0 // anything `never` is false
: A1 extends A2
? 1
: 0
export type Has = Not<
Extends, U1>
>
export type Or = {
0: {
0: 0
1: 1
}
1: {
0: 1
1: 1
}
}[B1][B2]
export type Keys = U extends unknown ? keyof U : never
type Cast = A extends B ? A : B;
export const type: unique symbol;
/**
* Used by group by
*/
export type GetScalarType = O extends object ? {
[P in keyof T]: P extends keyof O
? O[P]
: never
} : never
type FieldPaths<
T,
U = Omit
> = IsObject extends True ? U : T
type GetHavingFields = {
[K in keyof T]: Or<
Or, 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 extends object ? Merge> : never>
: never
: {} extends FieldPaths
? never
: K
}[keyof T]
/**
* Convert tuple to union
*/
type _TupleToUnion = T extends (infer E)[] ? E : never
type TupleToUnion = _TupleToUnion
type MaybeTupleToUnion = T extends any[] ? TupleToUnion : T
/**
* Like `Pick`, but additionally can also accept an array of keys
*/
type PickEnumerable | keyof T> = Prisma__Pick>
/**
* Exclude all keys with underscores
*/
type ExcludeUnderscoreKeys = T extends `_${string}` ? never : T
export type FieldRef = runtime.FieldRef
type FieldRefInputType = Model extends never ? never : FieldRef
export const ModelName: {
Organization: 'Organization',
Workspace: 'Workspace',
User: 'User',
Session: 'Session',
Role: 'Role',
Membership: 'Membership',
Invitation: 'Invitation',
Subscription: 'Subscription',
Project: 'Project',
LifecyclePhase: 'LifecyclePhase',
Risk: 'Risk',
Mitigation: 'Mitigation',
Evidence: 'Evidence',
Indicator: 'Indicator',
Experiment: 'Experiment',
ModelMetric: 'ModelMetric',
GateEvaluation: 'GateEvaluation',
GateCriterion: 'GateCriterion',
GateDecision: 'GateDecision',
Integration: 'Integration',
ExternalWorkItemMapping: 'ExternalWorkItemMapping',
IntegrationSyncRun: 'IntegrationSyncRun',
OAuthToken: 'OAuthToken',
ReportExport: 'ReportExport',
AuditEvent: 'AuditEvent',
UsageEvent: 'UsageEvent'
};
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> {
returns: Prisma.TypeMap
}
export type TypeMap = {
meta: {
modelProps: "organization" | "workspace" | "user" | "session" | "role" | "membership" | "invitation" | "subscription" | "project" | "lifecyclePhase" | "risk" | "mitigation" | "evidence" | "indicator" | "experiment" | "modelMetric" | "gateEvaluation" | "gateCriterion" | "gateDecision" | "integration" | "externalWorkItemMapping" | "integrationSyncRun" | "oAuthToken" | "reportExport" | "auditEvent" | "usageEvent"
txIsolationLevel: Prisma.TransactionIsolationLevel
}
model: {
Organization: {
payload: Prisma.$OrganizationPayload
fields: Prisma.OrganizationFieldRefs
operations: {
findUnique: {
args: Prisma.OrganizationFindUniqueArgs
result: $Utils.PayloadToResult | null
}
findUniqueOrThrow: {
args: Prisma.OrganizationFindUniqueOrThrowArgs
result: $Utils.PayloadToResult
}
findFirst: {
args: Prisma.OrganizationFindFirstArgs
result: $Utils.PayloadToResult | null
}
findFirstOrThrow: {
args: Prisma.OrganizationFindFirstOrThrowArgs
result: $Utils.PayloadToResult
}
findMany: {
args: Prisma.OrganizationFindManyArgs
result: $Utils.PayloadToResult[]
}
create: {
args: Prisma.OrganizationCreateArgs
result: $Utils.PayloadToResult
}
createMany: {
args: Prisma.OrganizationCreateManyArgs
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.OrganizationCreateManyAndReturnArgs
result: $Utils.PayloadToResult[]
}
delete: {
args: Prisma.OrganizationDeleteArgs
result: $Utils.PayloadToResult
}
update: {
args: Prisma.OrganizationUpdateArgs
result: $Utils.PayloadToResult
}
deleteMany: {
args: Prisma.OrganizationDeleteManyArgs
result: BatchPayload
}
updateMany: {
args: Prisma.OrganizationUpdateManyArgs
result: BatchPayload
}
upsert: {
args: Prisma.OrganizationUpsertArgs
result: $Utils.PayloadToResult
}
aggregate: {
args: Prisma.OrganizationAggregateArgs
result: $Utils.Optional
}
groupBy: {
args: Prisma.OrganizationGroupByArgs
result: $Utils.Optional[]
}
count: {
args: Prisma.OrganizationCountArgs
result: $Utils.Optional | number
}
}
}
Workspace: {
payload: Prisma.$WorkspacePayload
fields: Prisma.WorkspaceFieldRefs
operations: {
findUnique: {
args: Prisma.WorkspaceFindUniqueArgs
result: $Utils.PayloadToResult | null
}
findUniqueOrThrow: {
args: Prisma.WorkspaceFindUniqueOrThrowArgs
result: $Utils.PayloadToResult
}
findFirst: {
args: Prisma.WorkspaceFindFirstArgs
result: $Utils.PayloadToResult | null
}
findFirstOrThrow: {
args: Prisma.WorkspaceFindFirstOrThrowArgs
result: $Utils.PayloadToResult
}
findMany: {
args: Prisma.WorkspaceFindManyArgs
result: $Utils.PayloadToResult[]
}
create: {
args: Prisma.WorkspaceCreateArgs
result: $Utils.PayloadToResult
}
createMany: {
args: Prisma.WorkspaceCreateManyArgs
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.WorkspaceCreateManyAndReturnArgs
result: $Utils.PayloadToResult[]
}
delete: {
args: Prisma.WorkspaceDeleteArgs
result: $Utils.PayloadToResult
}
update: {
args: Prisma.WorkspaceUpdateArgs
result: $Utils.PayloadToResult
}
deleteMany: {
args: Prisma.WorkspaceDeleteManyArgs
result: BatchPayload
}
updateMany: {
args: Prisma.WorkspaceUpdateManyArgs
result: BatchPayload
}
upsert: {
args: Prisma.WorkspaceUpsertArgs
result: $Utils.PayloadToResult
}
aggregate: {
args: Prisma.WorkspaceAggregateArgs
result: $Utils.Optional
}
groupBy: {
args: Prisma.WorkspaceGroupByArgs
result: $Utils.Optional[]
}
count: {
args: Prisma.WorkspaceCountArgs
result: $Utils.Optional | number
}
}
}
User: {
payload: Prisma.$UserPayload
fields: Prisma.UserFieldRefs
operations: {
findUnique: {
args: Prisma.UserFindUniqueArgs
result: $Utils.PayloadToResult | null
}
findUniqueOrThrow: {
args: Prisma.UserFindUniqueOrThrowArgs
result: $Utils.PayloadToResult
}
findFirst: {
args: Prisma.UserFindFirstArgs
result: $Utils.PayloadToResult | null
}
findFirstOrThrow: {
args: Prisma.UserFindFirstOrThrowArgs
result: $Utils.PayloadToResult
}
findMany: {
args: Prisma.UserFindManyArgs
result: $Utils.PayloadToResult[]
}
create: {
args: Prisma.UserCreateArgs
result: $Utils.PayloadToResult
}
createMany: {
args: Prisma.UserCreateManyArgs
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.UserCreateManyAndReturnArgs
result: $Utils.PayloadToResult[]
}
delete: {
args: Prisma.UserDeleteArgs
result: $Utils.PayloadToResult
}
update: {
args: Prisma.UserUpdateArgs
result: $Utils.PayloadToResult
}
deleteMany: {
args: Prisma.UserDeleteManyArgs
result: BatchPayload
}
updateMany: {
args: Prisma.UserUpdateManyArgs
result: BatchPayload
}
upsert: {
args: Prisma.UserUpsertArgs
result: $Utils.PayloadToResult
}
aggregate: {
args: Prisma.UserAggregateArgs