@trycompai/db 1.3.22-canary.0 → 2.0.0

package/dist/generated/prisma/internal/class.d.ts

@@ -0,0 +1,1000 @@
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "./prismaNamespace.js";
+export type LogOptions<ClientOptions extends Prisma.PrismaClientOptions> = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never;
+export interface PrismaClientConstructor {
+    /**
+   * ## Prisma Client
+   *
+   * Type-safe database client for TypeScript
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+   * })
+   * // Fetch zero or more Attachments
+   * const attachments = await prisma.attachment.findMany()
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/client).
+   */
+    new <Options extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions, LogOpts extends LogOptions<Options> = LogOptions<Options>, OmitOpts extends Prisma.PrismaClientOptions['omit'] = Options extends {
+        omit: infer U;
+    } ? U : Prisma.PrismaClientOptions['omit'], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs>(options: Prisma.Subset<Options, Prisma.PrismaClientOptions>): PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+}
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more Attachments
+ * const attachments = await prisma.attachment.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out OmitOpts extends Prisma.PrismaClientOptions['omit'] = undefined, in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> {
+    [K: symbol]: {
+        types: Prisma.TypeMap<ExtArgs>['other'];
+    };
+    $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;
+    /**
+     * Connect with the database
+     */
+    $connect(): runtime.Types.Utils.JsPromise<void>;
+    /**
+     * Disconnect from the database
+     */
+    $disconnect(): runtime.Types.Utils.JsPromise<void>;
+    /**
+       * Executes a prepared raw query and returns the number of affected rows.
+       * @example
+       * ```
+       * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
+       * ```
+       *
+       * Read more in our [docs](https://pris.ly/d/raw-queries).
+       */
+    $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://pris.ly/d/raw-queries).
+     */
+    $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://pris.ly/d/raw-queries).
+     */
+    $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://pris.ly/d/raw-queries).
+     */
+    $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/orm/prisma-client/queries/transactions).
+     */
+    $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: {
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>;
+    $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): runtime.Types.Utils.JsPromise<R>;
+    $extends: runtime.Types.Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<Prisma.TypeMapCb<OmitOpts>, {
+        extArgs: ExtArgs;
+    }>>;
+    /**
+ * `prisma.attachment`: Exposes CRUD operations for the **Attachment** model.
+  * Example usage:
+  * ```ts
+  * // Fetch zero or more Attachments
+  * const attachments = await prisma.attachment.findMany()
+  * ```
+  */
+    get attachment(): Prisma.AttachmentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `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, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.employeeTrainingVideoCompletion`: Exposes CRUD operations for the **EmployeeTrainingVideoCompletion** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more EmployeeTrainingVideoCompletions
+      * const employeeTrainingVideoCompletions = await prisma.employeeTrainingVideoCompletion.findMany()
+      * ```
+      */
+    get employeeTrainingVideoCompletion(): Prisma.EmployeeTrainingVideoCompletionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `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<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.account`: Exposes CRUD operations for the **Account** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Accounts
+      * const accounts = await prisma.account.findMany()
+      * ```
+      */
+    get account(): Prisma.AccountDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.verification`: Exposes CRUD operations for the **Verification** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Verifications
+      * const verifications = await prisma.verification.findMany()
+      * ```
+      */
+    get verification(): Prisma.VerificationDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.jwks`: Exposes CRUD operations for the **Jwks** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Jwks
+      * const jwks = await prisma.jwks.findMany()
+      * ```
+      */
+    get jwks(): Prisma.JwksDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.member`: Exposes CRUD operations for the **Member** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Members
+      * const members = await prisma.member.findMany()
+      * ```
+      */
+    get member(): Prisma.MemberDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `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<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.organizationRole`: Exposes CRUD operations for the **OrganizationRole** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OrganizationRoles
+      * const organizationRoles = await prisma.organizationRole.findMany()
+      * ```
+      */
+    get organizationRole(): Prisma.OrganizationRoleDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.evidenceAutomationRun`: Exposes CRUD operations for the **EvidenceAutomationRun** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more EvidenceAutomationRuns
+      * const evidenceAutomationRuns = await prisma.evidenceAutomationRun.findMany()
+      * ```
+      */
+    get evidenceAutomationRun(): Prisma.EvidenceAutomationRunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.evidenceAutomationVersion`: Exposes CRUD operations for the **EvidenceAutomationVersion** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more EvidenceAutomationVersions
+      * const evidenceAutomationVersions = await prisma.evidenceAutomationVersion.findMany()
+      * ```
+      */
+    get evidenceAutomationVersion(): Prisma.EvidenceAutomationVersionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.evidenceAutomation`: Exposes CRUD operations for the **EvidenceAutomation** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more EvidenceAutomations
+      * const evidenceAutomations = await prisma.evidenceAutomation.findMany()
+      * ```
+      */
+    get evidenceAutomation(): Prisma.EvidenceAutomationDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.browserbaseContext`: Exposes CRUD operations for the **BrowserbaseContext** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more BrowserbaseContexts
+      * const browserbaseContexts = await prisma.browserbaseContext.findMany()
+      * ```
+      */
+    get browserbaseContext(): Prisma.BrowserbaseContextDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.browserAutomation`: Exposes CRUD operations for the **BrowserAutomation** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more BrowserAutomations
+      * const browserAutomations = await prisma.browserAutomation.findMany()
+      * ```
+      */
+    get browserAutomation(): Prisma.BrowserAutomationDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.browserAutomationRun`: Exposes CRUD operations for the **BrowserAutomationRun** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more BrowserAutomationRuns
+      * const browserAutomationRuns = await prisma.browserAutomationRun.findMany()
+      * ```
+      */
+    get browserAutomationRun(): Prisma.BrowserAutomationRunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.comment`: Exposes CRUD operations for the **Comment** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Comments
+      * const comments = await prisma.comment.findMany()
+      * ```
+      */
+    get comment(): Prisma.CommentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.context`: Exposes CRUD operations for the **Context** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Contexts
+      * const contexts = await prisma.context.findMany()
+      * ```
+      */
+    get context(): Prisma.ContextDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.controlDocumentType`: Exposes CRUD operations for the **ControlDocumentType** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more ControlDocumentTypes
+      * const controlDocumentTypes = await prisma.controlDocumentType.findMany()
+      * ```
+      */
+    get controlDocumentType(): Prisma.ControlDocumentTypeDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.control`: Exposes CRUD operations for the **Control** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Controls
+      * const controls = await prisma.control.findMany()
+      * ```
+      */
+    get control(): Prisma.ControlDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.device`: Exposes CRUD operations for the **Device** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Devices
+      * const devices = await prisma.device.findMany()
+      * ```
+      */
+    get device(): Prisma.DeviceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.dynamicIntegration`: Exposes CRUD operations for the **DynamicIntegration** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more DynamicIntegrations
+      * const dynamicIntegrations = await prisma.dynamicIntegration.findMany()
+      * ```
+      */
+    get dynamicIntegration(): Prisma.DynamicIntegrationDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.dynamicCheck`: Exposes CRUD operations for the **DynamicCheck** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more DynamicChecks
+      * const dynamicChecks = await prisma.dynamicCheck.findMany()
+      * ```
+      */
+    get dynamicCheck(): Prisma.DynamicCheckDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.evidenceSubmission`: Exposes CRUD operations for the **EvidenceSubmission** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more EvidenceSubmissions
+      * const evidenceSubmissions = await prisma.evidenceSubmission.findMany()
+      * ```
+      */
+    get evidenceSubmission(): Prisma.EvidenceSubmissionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.findingTemplate`: Exposes CRUD operations for the **FindingTemplate** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FindingTemplates
+      * const findingTemplates = await prisma.findingTemplate.findMany()
+      * ```
+      */
+    get findingTemplate(): Prisma.FindingTemplateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.finding`: Exposes CRUD operations for the **Finding** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Findings
+      * const findings = await prisma.finding.findMany()
+      * ```
+      */
+    get finding(): Prisma.FindingDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.fleetPolicyResult`: Exposes CRUD operations for the **FleetPolicyResult** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FleetPolicyResults
+      * const fleetPolicyResults = await prisma.fleetPolicyResult.findMany()
+      * ```
+      */
+    get fleetPolicyResult(): Prisma.FleetPolicyResultDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkEditorVideo`: Exposes CRUD operations for the **FrameworkEditorVideo** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkEditorVideos
+      * const frameworkEditorVideos = await prisma.frameworkEditorVideo.findMany()
+      * ```
+      */
+    get frameworkEditorVideo(): Prisma.FrameworkEditorVideoDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkEditorFramework`: Exposes CRUD operations for the **FrameworkEditorFramework** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkEditorFrameworks
+      * const frameworkEditorFrameworks = await prisma.frameworkEditorFramework.findMany()
+      * ```
+      */
+    get frameworkEditorFramework(): Prisma.FrameworkEditorFrameworkDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkEditorRequirement`: Exposes CRUD operations for the **FrameworkEditorRequirement** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkEditorRequirements
+      * const frameworkEditorRequirements = await prisma.frameworkEditorRequirement.findMany()
+      * ```
+      */
+    get frameworkEditorRequirement(): Prisma.FrameworkEditorRequirementDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkEditorPolicyTemplate`: Exposes CRUD operations for the **FrameworkEditorPolicyTemplate** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkEditorPolicyTemplates
+      * const frameworkEditorPolicyTemplates = await prisma.frameworkEditorPolicyTemplate.findMany()
+      * ```
+      */
+    get frameworkEditorPolicyTemplate(): Prisma.FrameworkEditorPolicyTemplateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkEditorTaskTemplate`: Exposes CRUD operations for the **FrameworkEditorTaskTemplate** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkEditorTaskTemplates
+      * const frameworkEditorTaskTemplates = await prisma.frameworkEditorTaskTemplate.findMany()
+      * ```
+      */
+    get frameworkEditorTaskTemplate(): Prisma.FrameworkEditorTaskTemplateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkEditorControlTemplate`: Exposes CRUD operations for the **FrameworkEditorControlTemplate** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkEditorControlTemplates
+      * const frameworkEditorControlTemplates = await prisma.frameworkEditorControlTemplate.findMany()
+      * ```
+      */
+    get frameworkEditorControlTemplate(): Prisma.FrameworkEditorControlTemplateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.frameworkInstance`: Exposes CRUD operations for the **FrameworkInstance** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more FrameworkInstances
+      * const frameworkInstances = await prisma.frameworkInstance.findMany()
+      * ```
+      */
+    get frameworkInstance(): Prisma.FrameworkInstanceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationProvider`: Exposes CRUD operations for the **IntegrationProvider** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationProviders
+      * const integrationProviders = await prisma.integrationProvider.findMany()
+      * ```
+      */
+    get integrationProvider(): Prisma.IntegrationProviderDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationConnection`: Exposes CRUD operations for the **IntegrationConnection** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationConnections
+      * const integrationConnections = await prisma.integrationConnection.findMany()
+      * ```
+      */
+    get integrationConnection(): Prisma.IntegrationConnectionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationCredentialVersion`: Exposes CRUD operations for the **IntegrationCredentialVersion** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationCredentialVersions
+      * const integrationCredentialVersions = await prisma.integrationCredentialVersion.findMany()
+      * ```
+      */
+    get integrationCredentialVersion(): Prisma.IntegrationCredentialVersionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationRun`: Exposes CRUD operations for the **IntegrationRun** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationRuns
+      * const integrationRuns = await prisma.integrationRun.findMany()
+      * ```
+      */
+    get integrationRun(): Prisma.IntegrationRunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationPlatformFinding`: Exposes CRUD operations for the **IntegrationPlatformFinding** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationPlatformFindings
+      * const integrationPlatformFindings = await prisma.integrationPlatformFinding.findMany()
+      * ```
+      */
+    get integrationPlatformFinding(): Prisma.IntegrationPlatformFindingDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationOAuthState`: Exposes CRUD operations for the **IntegrationOAuthState** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationOAuthStates
+      * const integrationOAuthStates = await prisma.integrationOAuthState.findMany()
+      * ```
+      */
+    get integrationOAuthState(): Prisma.IntegrationOAuthStateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationOAuthApp`: Exposes CRUD operations for the **IntegrationOAuthApp** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationOAuthApps
+      * const integrationOAuthApps = await prisma.integrationOAuthApp.findMany()
+      * ```
+      */
+    get integrationOAuthApp(): Prisma.IntegrationOAuthAppDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationCheckRun`: Exposes CRUD operations for the **IntegrationCheckRun** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationCheckRuns
+      * const integrationCheckRuns = await prisma.integrationCheckRun.findMany()
+      * ```
+      */
+    get integrationCheckRun(): Prisma.IntegrationCheckRunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationCheckResult`: Exposes CRUD operations for the **IntegrationCheckResult** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationCheckResults
+      * const integrationCheckResults = await prisma.integrationCheckResult.findMany()
+      * ```
+      */
+    get integrationCheckResult(): Prisma.IntegrationCheckResultDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationPlatformCredential`: Exposes CRUD operations for the **IntegrationPlatformCredential** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationPlatformCredentials
+      * const integrationPlatformCredentials = await prisma.integrationPlatformCredential.findMany()
+      * ```
+      */
+    get integrationPlatformCredential(): Prisma.IntegrationPlatformCredentialDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationSyncLog`: Exposes CRUD operations for the **IntegrationSyncLog** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationSyncLogs
+      * const integrationSyncLogs = await prisma.integrationSyncLog.findMany()
+      * ```
+      */
+    get integrationSyncLog(): Prisma.IntegrationSyncLogDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `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<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.integrationResult`: Exposes CRUD operations for the **IntegrationResult** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more IntegrationResults
+      * const integrationResults = await prisma.integrationResult.findMany()
+      * ```
+      */
+    get integrationResult(): Prisma.IntegrationResultDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.knowledgeBaseDocument`: Exposes CRUD operations for the **KnowledgeBaseDocument** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more KnowledgeBaseDocuments
+      * const knowledgeBaseDocuments = await prisma.knowledgeBaseDocument.findMany()
+      * ```
+      */
+    get knowledgeBaseDocument(): Prisma.KnowledgeBaseDocumentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.roleNotificationSetting`: Exposes CRUD operations for the **RoleNotificationSetting** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RoleNotificationSettings
+      * const roleNotificationSettings = await prisma.roleNotificationSetting.findMany()
+      * ```
+      */
+    get roleNotificationSetting(): Prisma.RoleNotificationSettingDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.onboarding`: Exposes CRUD operations for the **Onboarding** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Onboardings
+      * const onboardings = await prisma.onboarding.findMany()
+      * ```
+      */
+    get onboarding(): Prisma.OnboardingDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.organizationChart`: Exposes CRUD operations for the **OrganizationChart** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OrganizationCharts
+      * const organizationCharts = await prisma.organizationChart.findMany()
+      * ```
+      */
+    get organizationChart(): Prisma.OrganizationChartDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.organizationBilling`: Exposes CRUD operations for the **OrganizationBilling** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OrganizationBillings
+      * const organizationBillings = await prisma.organizationBilling.findMany()
+      * ```
+      */
+    get organizationBilling(): Prisma.OrganizationBillingDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `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<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.pentestSubscription`: Exposes CRUD operations for the **PentestSubscription** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more PentestSubscriptions
+      * const pentestSubscriptions = await prisma.pentestSubscription.findMany()
+      * ```
+      */
+    get pentestSubscription(): Prisma.PentestSubscriptionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.policy`: Exposes CRUD operations for the **Policy** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Policies
+      * const policies = await prisma.policy.findMany()
+      * ```
+      */
+    get policy(): Prisma.PolicyDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.policyVersion`: Exposes CRUD operations for the **PolicyVersion** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more PolicyVersions
+      * const policyVersions = await prisma.policyVersion.findMany()
+      * ```
+      */
+    get policyVersion(): Prisma.PolicyVersionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.questionnaire`: Exposes CRUD operations for the **Questionnaire** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Questionnaires
+      * const questionnaires = await prisma.questionnaire.findMany()
+      * ```
+      */
+    get questionnaire(): Prisma.QuestionnaireDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.questionnaireQuestionAnswer`: Exposes CRUD operations for the **QuestionnaireQuestionAnswer** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more QuestionnaireQuestionAnswers
+      * const questionnaireQuestionAnswers = await prisma.questionnaireQuestionAnswer.findMany()
+      * ```
+      */
+    get questionnaireQuestionAnswer(): Prisma.QuestionnaireQuestionAnswerDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.requirementMap`: Exposes CRUD operations for the **RequirementMap** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RequirementMaps
+      * const requirementMaps = await prisma.requirementMap.findMany()
+      * ```
+      */
+    get requirementMap(): Prisma.RequirementMapDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `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<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.secret`: Exposes CRUD operations for the **Secret** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Secrets
+      * const secrets = await prisma.secret.findMany()
+      * ```
+      */
+    get secret(): Prisma.SecretDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.securityPenetrationTestRun`: Exposes CRUD operations for the **SecurityPenetrationTestRun** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SecurityPenetrationTestRuns
+      * const securityPenetrationTestRuns = await prisma.securityPenetrationTestRun.findMany()
+      * ```
+      */
+    get securityPenetrationTestRun(): Prisma.SecurityPenetrationTestRunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.securityQuestionnaireManualAnswer`: Exposes CRUD operations for the **SecurityQuestionnaireManualAnswer** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SecurityQuestionnaireManualAnswers
+      * const securityQuestionnaireManualAnswers = await prisma.securityQuestionnaireManualAnswer.findMany()
+      * ```
+      */
+    get securityQuestionnaireManualAnswer(): Prisma.SecurityQuestionnaireManualAnswerDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.apiKey`: Exposes CRUD operations for the **ApiKey** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more ApiKeys
+      * const apiKeys = await prisma.apiKey.findMany()
+      * ```
+      */
+    get apiKey(): Prisma.ApiKeyDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.auditLog`: Exposes CRUD operations for the **AuditLog** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AuditLogs
+      * const auditLogs = await prisma.auditLog.findMany()
+      * ```
+      */
+    get auditLog(): Prisma.AuditLogDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.globalVendors`: Exposes CRUD operations for the **GlobalVendors** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more GlobalVendors
+      * const globalVendors = await prisma.globalVendors.findMany()
+      * ```
+      */
+    get globalVendors(): Prisma.GlobalVendorsDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.sOAFrameworkConfiguration`: Exposes CRUD operations for the **SOAFrameworkConfiguration** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SOAFrameworkConfigurations
+      * const sOAFrameworkConfigurations = await prisma.sOAFrameworkConfiguration.findMany()
+      * ```
+      */
+    get sOAFrameworkConfiguration(): Prisma.SOAFrameworkConfigurationDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.sOADocument`: Exposes CRUD operations for the **SOADocument** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SOADocuments
+      * const sOADocuments = await prisma.sOADocument.findMany()
+      * ```
+      */
+    get sOADocument(): Prisma.SOADocumentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.sOAAnswer`: Exposes CRUD operations for the **SOAAnswer** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SOAAnswers
+      * const sOAAnswers = await prisma.sOAAnswer.findMany()
+      * ```
+      */
+    get sOAAnswer(): Prisma.SOAAnswerDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.taskItem`: Exposes CRUD operations for the **TaskItem** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TaskItems
+      * const taskItems = await prisma.taskItem.findMany()
+      * ```
+      */
+    get taskItem(): Prisma.TaskItemDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.task`: Exposes CRUD operations for the **Task** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Tasks
+      * const tasks = await prisma.task.findMany()
+      * ```
+      */
+    get task(): Prisma.TaskDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trust`: Exposes CRUD operations for the **Trust** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Trusts
+      * const trusts = await prisma.trust.findMany()
+      * ```
+      */
+    get trust(): Prisma.TrustDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trustResource`: Exposes CRUD operations for the **TrustResource** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TrustResources
+      * const trustResources = await prisma.trustResource.findMany()
+      * ```
+      */
+    get trustResource(): Prisma.TrustResourceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trustAccessRequest`: Exposes CRUD operations for the **TrustAccessRequest** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TrustAccessRequests
+      * const trustAccessRequests = await prisma.trustAccessRequest.findMany()
+      * ```
+      */
+    get trustAccessRequest(): Prisma.TrustAccessRequestDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trustAccessGrant`: Exposes CRUD operations for the **TrustAccessGrant** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TrustAccessGrants
+      * const trustAccessGrants = await prisma.trustAccessGrant.findMany()
+      * ```
+      */
+    get trustAccessGrant(): Prisma.TrustAccessGrantDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trustNDAAgreement`: Exposes CRUD operations for the **TrustNDAAgreement** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TrustNDAAgreements
+      * const trustNDAAgreements = await prisma.trustNDAAgreement.findMany()
+      * ```
+      */
+    get trustNDAAgreement(): Prisma.TrustNDAAgreementDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trustDocument`: Exposes CRUD operations for the **TrustDocument** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TrustDocuments
+      * const trustDocuments = await prisma.trustDocument.findMany()
+      * ```
+      */
+    get trustDocument(): Prisma.TrustDocumentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.trustCustomLink`: Exposes CRUD operations for the **TrustCustomLink** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more TrustCustomLinks
+      * const trustCustomLinks = await prisma.trustCustomLink.findMany()
+      * ```
+      */
+    get trustCustomLink(): Prisma.TrustCustomLinkDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.vendor`: Exposes CRUD operations for the **Vendor** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Vendors
+      * const vendors = await prisma.vendor.findMany()
+      * ```
+      */
+    get vendor(): Prisma.VendorDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.vendorContact`: Exposes CRUD operations for the **VendorContact** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more VendorContacts
+      * const vendorContacts = await prisma.vendorContact.findMany()
+      * ```
+      */
+    get vendorContact(): Prisma.VendorContactDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+}
+export declare function getPrismaClientClass(): PrismaClientConstructor;
+//# sourceMappingURL=class.d.ts.map