@revisium/core 2.9.1 → 2.10.0-alpha.0

package/dist/src/__generated__/client/internal/prismaNamespace.d.ts

@@ -1,6 +1,6 @@
-import * as runtime from '@prisma/client/runtime/client';
-import type * as Prisma from '../models';
-import { type PrismaClient } from './class';
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../models";
+import { type PrismaClient } from "./class";
 export type * from '../models';
 export type DMMF = typeof runtime.DMMF;
 export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>;
@@ -42,9 +42,9 @@ export type InputJsonObject = runtime.InputJsonObject;
 export type InputJsonArray = runtime.InputJsonArray;
 export type InputJsonValue = runtime.InputJsonValue;
 export declare const NullTypes: {
-    DbNull: new (secret: never) => typeof runtime.DbNull;
-    JsonNull: new (secret: never) => typeof runtime.JsonNull;
-    AnyNull: new (secret: never) => typeof runtime.AnyNull;
+    DbNull: (new (secret: never) => typeof runtime.DbNull);
+    JsonNull: (new (secret: never) => typeof runtime.JsonNull);
+    AnyNull: (new (secret: never) => typeof runtime.AnyNull);
 };
 export declare const DbNull: runtime.DbNullClass;
 export declare const JsonNull: runtime.JsonNullClass;
@@ -116,9 +116,9 @@ type _Record<K extends keyof any, T> = {
 type NoExpand<T> = T extends unknown ? T : never;
 export type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
     [P in K]: O[P];
-} & O : O) | ({
+} & O : O) | {
     [P in keyof O as P extends K ? P : never]-?: O[P];
-} & O) : never>;
+} & 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>>;
 export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
@@ -171,14 +171,19 @@ export declare const ModelName: {
     readonly Endpoint: "Endpoint";
     readonly Table: "Table";
     readonly Row: "Row";
+    readonly FileBlob: "FileBlob";
+    readonly ProjectFileUsage: "ProjectFileUsage";
+    readonly TableMigration: "TableMigration";
     readonly OAuthClient: "OAuthClient";
     readonly OAuthAuthorizationCode: "OAuthAuthorizationCode";
     readonly OAuthAccessToken: "OAuthAccessToken";
     readonly OAuthRefreshToken: "OAuthRefreshToken";
+    readonly ApiKey: "ApiKey";
+    readonly LicenseCache: "LicenseCache";
+    readonly RefreshToken: "RefreshToken";
 };
 export type ModelName = (typeof ModelName)[keyof typeof ModelName];
-export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils
-    .Fn<{
+export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{
     extArgs: runtime.Types.Extensions.InternalArgs;
 }, runtime.Types.Utils.Record<string, any>> {
     returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>;
@@ -188,7 +193,7 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
         omit: GlobalOmitOptions;
     };
     meta: {
-        modelProps: 'instance' | 'user' | 'role' | 'permission' | 'organization' | 'userOrganization' | 'project' | 'userProject' | 'branch' | 'revision' | 'endpointVersion' | 'endpoint' | 'table' | 'row' | 'oAuthClient' | 'oAuthAuthorizationCode' | 'oAuthAccessToken' | 'oAuthRefreshToken';
+        modelProps: "instance" | "user" | "role" | "permission" | "organization" | "userOrganization" | "project" | "userProject" | "branch" | "revision" | "endpointVersion" | "endpoint" | "table" | "row" | "fileBlob" | "projectFileUsage" | "tableMigration" | "oAuthClient" | "oAuthAuthorizationCode" | "oAuthAccessToken" | "oAuthRefreshToken" | "apiKey" | "licenseCache" | "refreshToken";
         txIsolationLevel: TransactionIsolationLevel;
     };
     model: {
@@ -1228,6 +1233,228 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
                 };
             };
         };
+        FileBlob: {
+            payload: Prisma.$FileBlobPayload<ExtArgs>;
+            fields: Prisma.FileBlobFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FileBlobFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FileBlobFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FileBlobFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FileBlobFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>;
+                };
+                findMany: {
+                    args: Prisma.FileBlobFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>[];
+                };
+                create: {
+                    args: Prisma.FileBlobCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>;
+                };
+                createMany: {
+                    args: Prisma.FileBlobCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FileBlobCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>[];
+                };
+                delete: {
+                    args: Prisma.FileBlobDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>;
+                };
+                update: {
+                    args: Prisma.FileBlobUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FileBlobDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FileBlobUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FileBlobUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FileBlobUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FileBlobPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FileBlobAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFileBlob>;
+                };
+                groupBy: {
+                    args: Prisma.FileBlobGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FileBlobGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FileBlobCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FileBlobCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProjectFileUsage: {
+            payload: Prisma.$ProjectFileUsagePayload<ExtArgs>;
+            fields: Prisma.ProjectFileUsageFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProjectFileUsageFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProjectFileUsageFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProjectFileUsageFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProjectFileUsageFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>;
+                };
+                findMany: {
+                    args: Prisma.ProjectFileUsageFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>[];
+                };
+                create: {
+                    args: Prisma.ProjectFileUsageCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>;
+                };
+                createMany: {
+                    args: Prisma.ProjectFileUsageCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProjectFileUsageCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>[];
+                };
+                delete: {
+                    args: Prisma.ProjectFileUsageDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>;
+                };
+                update: {
+                    args: Prisma.ProjectFileUsageUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProjectFileUsageDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProjectFileUsageUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProjectFileUsageUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProjectFileUsageUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectFileUsagePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProjectFileUsageAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProjectFileUsage>;
+                };
+                groupBy: {
+                    args: Prisma.ProjectFileUsageGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProjectFileUsageGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProjectFileUsageCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProjectFileUsageCountAggregateOutputType> | number;
+                };
+            };
+        };
+        TableMigration: {
+            payload: Prisma.$TableMigrationPayload<ExtArgs>;
+            fields: Prisma.TableMigrationFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.TableMigrationFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.TableMigrationFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>;
+                };
+                findFirst: {
+                    args: Prisma.TableMigrationFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.TableMigrationFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>;
+                };
+                findMany: {
+                    args: Prisma.TableMigrationFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>[];
+                };
+                create: {
+                    args: Prisma.TableMigrationCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>;
+                };
+                createMany: {
+                    args: Prisma.TableMigrationCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.TableMigrationCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>[];
+                };
+                delete: {
+                    args: Prisma.TableMigrationDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>;
+                };
+                update: {
+                    args: Prisma.TableMigrationUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.TableMigrationDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.TableMigrationUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.TableMigrationUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>[];
+                };
+                upsert: {
+                    args: Prisma.TableMigrationUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TableMigrationPayload>;
+                };
+                aggregate: {
+                    args: Prisma.TableMigrationAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateTableMigration>;
+                };
+                groupBy: {
+                    args: Prisma.TableMigrationGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.TableMigrationGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.TableMigrationCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.TableMigrationCountAggregateOutputType> | number;
+                };
+            };
+        };
         OAuthClient: {
             payload: Prisma.$OAuthClientPayload<ExtArgs>;
             fields: Prisma.OAuthClientFieldRefs;
@@ -1524,6 +1751,228 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
                 };
             };
         };
+        ApiKey: {
+            payload: Prisma.$ApiKeyPayload<ExtArgs>;
+            fields: Prisma.ApiKeyFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ApiKeyFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ApiKeyFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ApiKeyFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ApiKeyFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                findMany: {
+                    args: Prisma.ApiKeyFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>[];
+                };
+                create: {
+                    args: Prisma.ApiKeyCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                createMany: {
+                    args: Prisma.ApiKeyCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ApiKeyCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>[];
+                };
+                delete: {
+                    args: Prisma.ApiKeyDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                update: {
+                    args: Prisma.ApiKeyUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ApiKeyDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ApiKeyUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ApiKeyUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ApiKeyUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ApiKeyPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ApiKeyAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateApiKey>;
+                };
+                groupBy: {
+                    args: Prisma.ApiKeyGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ApiKeyGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ApiKeyCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ApiKeyCountAggregateOutputType> | number;
+                };
+            };
+        };
+        LicenseCache: {
+            payload: Prisma.$LicenseCachePayload<ExtArgs>;
+            fields: Prisma.LicenseCacheFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.LicenseCacheFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.LicenseCacheFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>;
+                };
+                findFirst: {
+                    args: Prisma.LicenseCacheFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.LicenseCacheFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>;
+                };
+                findMany: {
+                    args: Prisma.LicenseCacheFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>[];
+                };
+                create: {
+                    args: Prisma.LicenseCacheCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>;
+                };
+                createMany: {
+                    args: Prisma.LicenseCacheCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.LicenseCacheCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>[];
+                };
+                delete: {
+                    args: Prisma.LicenseCacheDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>;
+                };
+                update: {
+                    args: Prisma.LicenseCacheUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.LicenseCacheDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.LicenseCacheUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.LicenseCacheUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>[];
+                };
+                upsert: {
+                    args: Prisma.LicenseCacheUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LicenseCachePayload>;
+                };
+                aggregate: {
+                    args: Prisma.LicenseCacheAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateLicenseCache>;
+                };
+                groupBy: {
+                    args: Prisma.LicenseCacheGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.LicenseCacheGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.LicenseCacheCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.LicenseCacheCountAggregateOutputType> | number;
+                };
+            };
+        };
+        RefreshToken: {
+            payload: Prisma.$RefreshTokenPayload<ExtArgs>;
+            fields: Prisma.RefreshTokenFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.RefreshTokenFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.RefreshTokenFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>;
+                };
+                findFirst: {
+                    args: Prisma.RefreshTokenFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.RefreshTokenFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>;
+                };
+                findMany: {
+                    args: Prisma.RefreshTokenFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>[];
+                };
+                create: {
+                    args: Prisma.RefreshTokenCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>;
+                };
+                createMany: {
+                    args: Prisma.RefreshTokenCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.RefreshTokenCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>[];
+                };
+                delete: {
+                    args: Prisma.RefreshTokenDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>;
+                };
+                update: {
+                    args: Prisma.RefreshTokenUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.RefreshTokenDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.RefreshTokenUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.RefreshTokenUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>[];
+                };
+                upsert: {
+                    args: Prisma.RefreshTokenUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RefreshTokenPayload>;
+                };
+                aggregate: {
+                    args: Prisma.RefreshTokenAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateRefreshToken>;
+                };
+                groupBy: {
+                    args: Prisma.RefreshTokenGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RefreshTokenGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.RefreshTokenCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RefreshTokenCountAggregateOutputType> | number;
+                };
+            };
+        };
     };
 } & {
     other: {
@@ -1572,6 +2021,7 @@ export declare const UserScalarFieldEnum: {
     readonly isEmailConfirmed: "isEmailConfirmed";
     readonly emailCode: "emailCode";
     readonly roleId: "roleId";
+    readonly tokenVersion: "tokenVersion";
 };
 export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum];
 export declare const RoleScalarFieldEnum: {
@@ -1680,6 +2130,51 @@ export declare const RowScalarFieldEnum: {
     readonly schemaHash: "schemaHash";
 };
 export type RowScalarFieldEnum = (typeof RowScalarFieldEnum)[keyof typeof RowScalarFieldEnum];
+export declare const FileBlobScalarFieldEnum: {
+    readonly id: "id";
+    readonly createdAt: "createdAt";
+    readonly deletedAt: "deletedAt";
+    readonly projectId: "projectId";
+    readonly hash: "hash";
+    readonly size: "size";
+};
+export type FileBlobScalarFieldEnum = (typeof FileBlobScalarFieldEnum)[keyof typeof FileBlobScalarFieldEnum];
+export declare const ProjectFileUsageScalarFieldEnum: {
+    readonly projectId: "projectId";
+    readonly fileBytes: "fileBytes";
+    readonly updatedAt: "updatedAt";
+};
+export type ProjectFileUsageScalarFieldEnum = (typeof ProjectFileUsageScalarFieldEnum)[keyof typeof ProjectFileUsageScalarFieldEnum];
+export declare const TableMigrationScalarFieldEnum: {
+    readonly id: "id";
+    readonly revisionId: "revisionId";
+    readonly tableId: "tableId";
+    readonly sourceTableVersionId: "sourceTableVersionId";
+    readonly shadowTableVersionId: "shadowTableVersionId";
+    readonly status: "status";
+    readonly phase: "phase";
+    readonly patches: "patches";
+    readonly previousSchema: "previousSchema";
+    readonly previousSchemaHash: "previousSchemaHash";
+    readonly targetSchemaHash: "targetSchemaHash";
+    readonly totalRows: "totalRows";
+    readonly copiedRows: "copiedRows";
+    readonly lastCopiedRowId: "lastCopiedRowId";
+    readonly batchSize: "batchSize";
+    readonly currentBatch: "currentBatch";
+    readonly totalBatches: "totalBatches";
+    readonly createdAt: "createdAt";
+    readonly startedAt: "startedAt";
+    readonly completedAt: "completedAt";
+    readonly lastProgressAt: "lastProgressAt";
+    readonly lockedBy: "lockedBy";
+    readonly lockedAt: "lockedAt";
+    readonly heartbeatAt: "heartbeatAt";
+    readonly errorMessage: "errorMessage";
+    readonly retryCount: "retryCount";
+    readonly maxRetries: "maxRetries";
+};
+export type TableMigrationScalarFieldEnum = (typeof TableMigrationScalarFieldEnum)[keyof typeof TableMigrationScalarFieldEnum];
 export declare const OAuthClientScalarFieldEnum: {
     readonly id: "id";
     readonly clientSecretHash: "clientSecretHash";
@@ -1725,6 +2220,50 @@ export declare const OAuthRefreshTokenScalarFieldEnum: {
     readonly createdAt: "createdAt";
 };
 export type OAuthRefreshTokenScalarFieldEnum = (typeof OAuthRefreshTokenScalarFieldEnum)[keyof typeof OAuthRefreshTokenScalarFieldEnum];
+export declare const ApiKeyScalarFieldEnum: {
+    readonly id: "id";
+    readonly prefix: "prefix";
+    readonly keyHash: "keyHash";
+    readonly type: "type";
+    readonly name: "name";
+    readonly userId: "userId";
+    readonly serviceId: "serviceId";
+    readonly internalServiceName: "internalServiceName";
+    readonly organizationId: "organizationId";
+    readonly projectIds: "projectIds";
+    readonly branchNames: "branchNames";
+    readonly tableIds: "tableIds";
+    readonly permissions: "permissions";
+    readonly readOnly: "readOnly";
+    readonly allowedIps: "allowedIps";
+    readonly expiresAt: "expiresAt";
+    readonly revokedAt: "revokedAt";
+    readonly replacedById: "replacedById";
+    readonly lastUsedAt: "lastUsedAt";
+    readonly lastUsedIp: "lastUsedIp";
+    readonly createdAt: "createdAt";
+};
+export type ApiKeyScalarFieldEnum = (typeof ApiKeyScalarFieldEnum)[keyof typeof ApiKeyScalarFieldEnum];
+export declare const LicenseCacheScalarFieldEnum: {
+    readonly id: "id";
+    readonly payload: "payload";
+    readonly validatedAt: "validatedAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type LicenseCacheScalarFieldEnum = (typeof LicenseCacheScalarFieldEnum)[keyof typeof LicenseCacheScalarFieldEnum];
+export declare const RefreshTokenScalarFieldEnum: {
+    readonly id: "id";
+    readonly tokenHash: "tokenHash";
+    readonly userId: "userId";
+    readonly familyId: "familyId";
+    readonly expiresAt: "expiresAt";
+    readonly revokedAt: "revokedAt";
+    readonly createdAt: "createdAt";
+    readonly userAgent: "userAgent";
+    readonly ip: "ip";
+};
+export type RefreshTokenScalarFieldEnum = (typeof RefreshTokenScalarFieldEnum)[keyof typeof RefreshTokenScalarFieldEnum];
 export declare const SortOrder: {
     readonly asc: "asc";
     readonly desc: "desc";
@@ -1841,6 +2380,31 @@ export declare const RowOrderByRelevanceFieldEnum: {
     readonly schemaHash: "schemaHash";
 };
 export type RowOrderByRelevanceFieldEnum = (typeof RowOrderByRelevanceFieldEnum)[keyof typeof RowOrderByRelevanceFieldEnum];
+export declare const FileBlobOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly projectId: "projectId";
+    readonly hash: "hash";
+};
+export type FileBlobOrderByRelevanceFieldEnum = (typeof FileBlobOrderByRelevanceFieldEnum)[keyof typeof FileBlobOrderByRelevanceFieldEnum];
+export declare const ProjectFileUsageOrderByRelevanceFieldEnum: {
+    readonly projectId: "projectId";
+};
+export type ProjectFileUsageOrderByRelevanceFieldEnum = (typeof ProjectFileUsageOrderByRelevanceFieldEnum)[keyof typeof ProjectFileUsageOrderByRelevanceFieldEnum];
+export declare const TableMigrationOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly revisionId: "revisionId";
+    readonly tableId: "tableId";
+    readonly sourceTableVersionId: "sourceTableVersionId";
+    readonly shadowTableVersionId: "shadowTableVersionId";
+    readonly status: "status";
+    readonly phase: "phase";
+    readonly previousSchemaHash: "previousSchemaHash";
+    readonly targetSchemaHash: "targetSchemaHash";
+    readonly lastCopiedRowId: "lastCopiedRowId";
+    readonly lockedBy: "lockedBy";
+    readonly errorMessage: "errorMessage";
+};
+export type TableMigrationOrderByRelevanceFieldEnum = (typeof TableMigrationOrderByRelevanceFieldEnum)[keyof typeof TableMigrationOrderByRelevanceFieldEnum];
 export declare const OAuthClientOrderByRelevanceFieldEnum: {
     readonly id: "id";
     readonly clientSecretHash: "clientSecretHash";
@@ -1875,19 +2439,53 @@ export declare const OAuthRefreshTokenOrderByRelevanceFieldEnum: {
     readonly scope: "scope";
 };
 export type OAuthRefreshTokenOrderByRelevanceFieldEnum = (typeof OAuthRefreshTokenOrderByRelevanceFieldEnum)[keyof typeof OAuthRefreshTokenOrderByRelevanceFieldEnum];
+export declare const ApiKeyOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly prefix: "prefix";
+    readonly keyHash: "keyHash";
+    readonly name: "name";
+    readonly userId: "userId";
+    readonly serviceId: "serviceId";
+    readonly internalServiceName: "internalServiceName";
+    readonly organizationId: "organizationId";
+    readonly projectIds: "projectIds";
+    readonly branchNames: "branchNames";
+    readonly tableIds: "tableIds";
+    readonly allowedIps: "allowedIps";
+    readonly replacedById: "replacedById";
+    readonly lastUsedIp: "lastUsedIp";
+};
+export type ApiKeyOrderByRelevanceFieldEnum = (typeof ApiKeyOrderByRelevanceFieldEnum)[keyof typeof ApiKeyOrderByRelevanceFieldEnum];
+export declare const LicenseCacheOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+};
+export type LicenseCacheOrderByRelevanceFieldEnum = (typeof LicenseCacheOrderByRelevanceFieldEnum)[keyof typeof LicenseCacheOrderByRelevanceFieldEnum];
+export declare const RefreshTokenOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly tokenHash: "tokenHash";
+    readonly userId: "userId";
+    readonly familyId: "familyId";
+    readonly userAgent: "userAgent";
+    readonly ip: "ip";
+};
+export type RefreshTokenOrderByRelevanceFieldEnum = (typeof RefreshTokenOrderByRelevanceFieldEnum)[keyof typeof RefreshTokenOrderByRelevanceFieldEnum];
 export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>;
 export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>;
 export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>;
 export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>;
 export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>;
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
+export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>;
 export type EnumRoleLevelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RoleLevel'>;
 export type ListEnumRoleLevelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RoleLevel[]'>;
 export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>;
 export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>;
-export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
-export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>;
 export type EnumEndpointTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'EndpointType'>;
 export type ListEnumEndpointTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'EndpointType[]'>;
+export type BigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt'>;
+export type ListBigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt[]'>;
+export type EnumApiKeyTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ApiKeyType'>;
+export type ListEnumApiKeyTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ApiKeyType[]'>;
 export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>;
 export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>;
 export type BatchPayload = {
@@ -1928,10 +2526,16 @@ export type GlobalOmitConfig = {
     endpoint?: Prisma.EndpointOmit;
     table?: Prisma.TableOmit;
     row?: Prisma.RowOmit;
+    fileBlob?: Prisma.FileBlobOmit;
+    projectFileUsage?: Prisma.ProjectFileUsageOmit;
+    tableMigration?: Prisma.TableMigrationOmit;
     oAuthClient?: Prisma.OAuthClientOmit;
     oAuthAuthorizationCode?: Prisma.OAuthAuthorizationCodeOmit;
     oAuthAccessToken?: Prisma.OAuthAccessTokenOmit;
     oAuthRefreshToken?: Prisma.OAuthRefreshTokenOmit;
+    apiKey?: Prisma.ApiKeyOmit;
+    licenseCache?: Prisma.LicenseCacheOmit;
+    refreshToken?: Prisma.RefreshTokenOmit;
 };
 export type LogLevel = 'info' | 'query' | 'warn' | 'error';
 export type LogDefinition = {