@wardby/cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,605 @@
+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 Agents
+   * const agents = await prisma.agent.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.PrismaClientConstructorArgs<Options>): 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 Agents
+ * const agents = await prisma.agent.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'] = Prisma.PrismaClientOptions['omit'], 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?: {
+        maxWait?: number;
+        timeout?: number;
+        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.agent`: Exposes CRUD operations for the **Agent** model.
+  * Example usage:
+  * ```ts
+  * // Fetch zero or more Agents
+  * const agents = await prisma.agent.findMany()
+  * ```
+  */
+    get agent(): Prisma.AgentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.agentSubAgent`: Exposes CRUD operations for the **AgentSubAgent** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentSubAgents
+      * const agentSubAgents = await prisma.agentSubAgent.findMany()
+      * ```
+      */
+    get agentSubAgent(): Prisma.AgentSubAgentDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.budgetGroup`: Exposes CRUD operations for the **BudgetGroup** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more BudgetGroups
+      * const budgetGroups = await prisma.budgetGroup.findMany()
+      * ```
+      */
+    get budgetGroup(): Prisma.BudgetGroupDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.tool`: Exposes CRUD operations for the **Tool** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Tools
+      * const tools = await prisma.tool.findMany()
+      * ```
+      */
+    get tool(): Prisma.ToolDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.agentTool`: Exposes CRUD operations for the **AgentTool** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentTools
+      * const agentTools = await prisma.agentTool.findMany()
+      * ```
+      */
+    get agentTool(): Prisma.AgentToolDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.datastore`: Exposes CRUD operations for the **Datastore** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Datastores
+      * const datastores = await prisma.datastore.findMany()
+      * ```
+      */
+    get datastore(): Prisma.DatastoreDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.agentDatastore`: Exposes CRUD operations for the **AgentDatastore** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentDatastores
+      * const agentDatastores = await prisma.agentDatastore.findMany()
+      * ```
+      */
+    get agentDatastore(): Prisma.AgentDatastoreDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.datastoreEntry`: Exposes CRUD operations for the **DatastoreEntry** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more DatastoreEntries
+      * const datastoreEntries = await prisma.datastoreEntry.findMany()
+      * ```
+      */
+    get datastoreEntry(): Prisma.DatastoreEntryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.agentMemory`: Exposes CRUD operations for the **AgentMemory** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentMemories
+      * const agentMemories = await prisma.agentMemory.findMany()
+      * ```
+      */
+    get agentMemory(): Prisma.AgentMemoryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.run`: Exposes CRUD operations for the **Run** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Runs
+      * const runs = await prisma.run.findMany()
+      * ```
+      */
+    get run(): Prisma.RunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.codingAgentProfile`: Exposes CRUD operations for the **CodingAgentProfile** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more CodingAgentProfiles
+      * const codingAgentProfiles = await prisma.codingAgentProfile.findMany()
+      * ```
+      */
+    get codingAgentProfile(): Prisma.CodingAgentProfileDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.codingRun`: Exposes CRUD operations for the **CodingRun** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more CodingRuns
+      * const codingRuns = await prisma.codingRun.findMany()
+      * ```
+      */
+    get codingRun(): Prisma.CodingRunDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.codingService`: Exposes CRUD operations for the **CodingService** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more CodingServices
+      * const codingServices = await prisma.codingService.findMany()
+      * ```
+      */
+    get codingService(): Prisma.CodingServiceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.codingProxySession`: Exposes CRUD operations for the **CodingProxySession** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more CodingProxySessions
+      * const codingProxySessions = await prisma.codingProxySession.findMany()
+      * ```
+      */
+    get codingProxySession(): Prisma.CodingProxySessionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.codingProxyRequest`: Exposes CRUD operations for the **CodingProxyRequest** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more CodingProxyRequests
+      * const codingProxyRequests = await prisma.codingProxyRequest.findMany()
+      * ```
+      */
+    get codingProxyRequest(): Prisma.CodingProxyRequestDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryAllowance`: Exposes CRUD operations for the **RegistryAllowance** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryAllowances
+      * const registryAllowances = await prisma.registryAllowance.findMany()
+      * ```
+      */
+    get registryAllowance(): Prisma.RegistryAllowanceDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryFetch`: Exposes CRUD operations for the **RegistryFetch** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryFetches
+      * const registryFetches = await prisma.registryFetch.findMany()
+      * ```
+      */
+    get registryFetch(): Prisma.RegistryFetchDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryVersionFact`: Exposes CRUD operations for the **RegistryVersionFact** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryVersionFacts
+      * const registryVersionFacts = await prisma.registryVersionFact.findMany()
+      * ```
+      */
+    get registryVersionFact(): Prisma.RegistryVersionFactDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryApprovedVersion`: Exposes CRUD operations for the **RegistryApprovedVersion** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryApprovedVersions
+      * const registryApprovedVersions = await prisma.registryApprovedVersion.findMany()
+      * ```
+      */
+    get registryApprovedVersion(): Prisma.RegistryApprovedVersionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.registryPlanRefusal`: Exposes CRUD operations for the **RegistryPlanRefusal** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RegistryPlanRefusals
+      * const registryPlanRefusals = await prisma.registryPlanRefusal.findMany()
+      * ```
+      */
+    get registryPlanRefusal(): Prisma.RegistryPlanRefusalDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.schedulerLease`: Exposes CRUD operations for the **SchedulerLease** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SchedulerLeases
+      * const schedulerLeases = await prisma.schedulerLease.findMany()
+      * ```
+      */
+    get schedulerLease(): Prisma.SchedulerLeaseDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.principal`: Exposes CRUD operations for the **Principal** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Principals
+      * const principals = await prisma.principal.findMany()
+      * ```
+      */
+    get principal(): Prisma.PrincipalDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.resourceGrant`: Exposes CRUD operations for the **ResourceGrant** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more ResourceGrants
+      * const resourceGrants = await prisma.resourceGrant.findMany()
+      * ```
+      */
+    get resourceGrant(): Prisma.ResourceGrantDelegate<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.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.agentSecret`: Exposes CRUD operations for the **AgentSecret** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentSecrets
+      * const agentSecrets = await prisma.agentSecret.findMany()
+      * ```
+      */
+    get agentSecret(): Prisma.AgentSecretDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.secretElicitationOutcome`: Exposes CRUD operations for the **SecretElicitationOutcome** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more SecretElicitationOutcomes
+      * const secretElicitationOutcomes = await prisma.secretElicitationOutcome.findMany()
+      * ```
+      */
+    get secretElicitationOutcome(): Prisma.SecretElicitationOutcomeDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.webhook`: Exposes CRUD operations for the **Webhook** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Webhooks
+      * const webhooks = await prisma.webhook.findMany()
+      * ```
+      */
+    get webhook(): Prisma.WebhookDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.oAuthClient`: Exposes CRUD operations for the **OAuthClient** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OAuthClients
+      * const oAuthClients = await prisma.oAuthClient.findMany()
+      * ```
+      */
+    get oAuthClient(): Prisma.OAuthClientDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.oAuthGrant`: Exposes CRUD operations for the **OAuthGrant** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OAuthGrants
+      * const oAuthGrants = await prisma.oAuthGrant.findMany()
+      * ```
+      */
+    get oAuthGrant(): Prisma.OAuthGrantDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.authUser`: Exposes CRUD operations for the **AuthUser** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AuthUsers
+      * const authUsers = await prisma.authUser.findMany()
+      * ```
+      */
+    get authUser(): Prisma.AuthUserDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.authLoginKey`: Exposes CRUD operations for the **AuthLoginKey** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AuthLoginKeys
+      * const authLoginKeys = await prisma.authLoginKey.findMany()
+      * ```
+      */
+    get authLoginKey(): Prisma.AuthLoginKeyDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.authSession`: Exposes CRUD operations for the **AuthSession** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AuthSessions
+      * const authSessions = await prisma.authSession.findMany()
+      * ```
+      */
+    get authSession(): Prisma.AuthSessionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.authFormChallenge`: Exposes CRUD operations for the **AuthFormChallenge** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AuthFormChallenges
+      * const authFormChallenges = await prisma.authFormChallenge.findMany()
+      * ```
+      */
+    get authFormChallenge(): Prisma.AuthFormChallengeDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.oAuthAuthorizationRequest`: Exposes CRUD operations for the **OAuthAuthorizationRequest** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OAuthAuthorizationRequests
+      * const oAuthAuthorizationRequests = await prisma.oAuthAuthorizationRequest.findMany()
+      * ```
+      */
+    get oAuthAuthorizationRequest(): Prisma.OAuthAuthorizationRequestDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.oAuthAuthorizationCode`: Exposes CRUD operations for the **OAuthAuthorizationCode** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OAuthAuthorizationCodes
+      * const oAuthAuthorizationCodes = await prisma.oAuthAuthorizationCode.findMany()
+      * ```
+      */
+    get oAuthAuthorizationCode(): Prisma.OAuthAuthorizationCodeDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.oAuthFamily`: Exposes CRUD operations for the **OAuthFamily** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more OAuthFamilies
+      * const oAuthFamilies = await prisma.oAuthFamily.findMany()
+      * ```
+      */
+    get oAuthFamily(): Prisma.OAuthFamilyDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.authRateLimit`: Exposes CRUD operations for the **AuthRateLimit** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AuthRateLimits
+      * const authRateLimits = await prisma.authRateLimit.findMany()
+      * ```
+      */
+    get authRateLimit(): Prisma.AuthRateLimitDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.agentRepository`: Exposes CRUD operations for the **AgentRepository** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more AgentRepositories
+      * const agentRepositories = await prisma.agentRepository.findMany()
+      * ```
+      */
+    get agentRepository(): Prisma.AgentRepositoryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.runHostCheck`: Exposes CRUD operations for the **RunHostCheck** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RunHostChecks
+      * const runHostChecks = await prisma.runHostCheck.findMany()
+      * ```
+      */
+    get runHostCheck(): Prisma.RunHostCheckDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.runHostStatus`: Exposes CRUD operations for the **RunHostStatus** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more RunHostStatuses
+      * const runHostStatuses = await prisma.runHostStatus.findMany()
+      * ```
+      */
+    get runHostStatus(): Prisma.RunHostStatusDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.hostEventDelivery`: Exposes CRUD operations for the **HostEventDelivery** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more HostEventDeliveries
+      * const hostEventDeliveries = await prisma.hostEventDelivery.findMany()
+      * ```
+      */
+    get hostEventDelivery(): Prisma.HostEventDeliveryDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.hostIdentity`: Exposes CRUD operations for the **HostIdentity** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more HostIdentities
+      * const hostIdentities = await prisma.hostIdentity.findMany()
+      * ```
+      */
+    get hostIdentity(): Prisma.HostIdentityDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.hostIdentityLinkRequest`: Exposes CRUD operations for the **HostIdentityLinkRequest** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more HostIdentityLinkRequests
+      * const hostIdentityLinkRequests = await prisma.hostIdentityLinkRequest.findMany()
+      * ```
+      */
+    get hostIdentityLinkRequest(): Prisma.HostIdentityLinkRequestDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+}
+export declare function getPrismaClientClass(): PrismaClientConstructor;