Type Alias TypeMap<ExtArgs, GlobalOmitOptions>

TypeMap: {
    globalOmitOptions: { omit: GlobalOmitOptions };
    meta: {
        modelProps:
            | "auditLog"
            | "app"
            | "resource"
            | "role"
            | "rolePermissions"
            | "permission"
            | "user"
            | "userRole"
            | "accessToken"
            | "accessTokenPermissions";
        txIsolationLevel: Prisma.TransactionIsolationLevel;
    };
    model: {
        AccessToken: {
            fields: AccessTokenFieldRefs;
            operations: {
                aggregate: {
                    args: AccessTokenAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateAccessToken>;
                };
                count: {
                    args: AccessTokenCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<AccessTokenCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: AccessTokenCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>;
                };
                createMany: {
                    args: AccessTokenCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: AccessTokenCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>[];
                };
                delete: {
                    args: AccessTokenDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>;
                };
                deleteMany: {
                    args: AccessTokenDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: AccessTokenFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload> | null;
                };
                findFirstOrThrow: {
                    args: AccessTokenFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>;
                };
                findMany: {
                    args: AccessTokenFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>[];
                };
                findUnique: {
                    args: AccessTokenFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload> | null;
                };
                findUniqueOrThrow: {
                    args: AccessTokenFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>;
                };
                groupBy: {
                    args: AccessTokenGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AccessTokenGroupByOutputType>[];
                };
                update: {
                    args: AccessTokenUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>;
                };
                updateMany: {
                    args: AccessTokenUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: AccessTokenUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>[];
                };
                upsert: {
                    args: AccessTokenUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AccessTokenPayload>;
                };
            };
            payload: $AccessTokenPayload<ExtArgs>;
        };
        AccessTokenPermissions: {
            fields: AccessTokenPermissionsFieldRefs;
            operations: {
                aggregate: {
                    args: AccessTokenPermissionsAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateAccessTokenPermissions>;
                };
                count: {
                    args: AccessTokenPermissionsCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<
                            AccessTokenPermissionsCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: AccessTokenPermissionsCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >;
                };
                createMany: {
                    args: AccessTokenPermissionsCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: AccessTokenPermissionsCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >[];
                };
                delete: {
                    args: AccessTokenPermissionsDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >;
                };
                deleteMany: {
                    args: AccessTokenPermissionsDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: AccessTokenPermissionsFindFirstArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.PayloadToResult<
                            $AccessTokenPermissionsPayload,
                        >
                        | null;
                };
                findFirstOrThrow: {
                    args: AccessTokenPermissionsFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >;
                };
                findMany: {
                    args: AccessTokenPermissionsFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >[];
                };
                findUnique: {
                    args: AccessTokenPermissionsFindUniqueArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.PayloadToResult<
                            $AccessTokenPermissionsPayload,
                        >
                        | null;
                };
                findUniqueOrThrow: {
                    args: AccessTokenPermissionsFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >;
                };
                groupBy: {
                    args: AccessTokenPermissionsGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<
                        AccessTokenPermissionsGroupByOutputType,
                    >[];
                };
                update: {
                    args: AccessTokenPermissionsUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >;
                };
                updateMany: {
                    args: AccessTokenPermissionsUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: AccessTokenPermissionsUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >[];
                };
                upsert: {
                    args: AccessTokenPermissionsUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<
                        $AccessTokenPermissionsPayload,
                    >;
                };
            };
            payload: $AccessTokenPermissionsPayload<ExtArgs>;
        };
        App: {
            fields: AppFieldRefs;
            operations: {
                aggregate: {
                    args: AppAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateApp>;
                };
                count: {
                    args: AppCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<AppCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: AppCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>;
                };
                createMany: {
                    args: AppCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: AppCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>[];
                };
                delete: {
                    args: AppDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>;
                };
                deleteMany: {
                    args: AppDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: AppFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload> | null;
                };
                findFirstOrThrow: {
                    args: AppFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>;
                };
                findMany: {
                    args: AppFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>[];
                };
                findUnique: {
                    args: AppFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload> | null;
                };
                findUniqueOrThrow: {
                    args: AppFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>;
                };
                groupBy: {
                    args: AppGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AppGroupByOutputType>[];
                };
                update: {
                    args: AppUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>;
                };
                updateMany: {
                    args: AppUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: AppUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>[];
                };
                upsert: {
                    args: AppUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AppPayload>;
                };
            };
            payload: $AppPayload<ExtArgs>;
        };
        AuditLog: {
            fields: AuditLogFieldRefs;
            operations: {
                aggregate: {
                    args: AuditLogAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateAuditLog>;
                };
                count: {
                    args: AuditLogCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<AuditLogCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: AuditLogCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>;
                };
                createMany: {
                    args: AuditLogCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: AuditLogCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>[];
                };
                delete: {
                    args: AuditLogDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>;
                };
                deleteMany: {
                    args: AuditLogDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: AuditLogFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload> | null;
                };
                findFirstOrThrow: {
                    args: AuditLogFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>;
                };
                findMany: {
                    args: AuditLogFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>[];
                };
                findUnique: {
                    args: AuditLogFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload> | null;
                };
                findUniqueOrThrow: {
                    args: AuditLogFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>;
                };
                groupBy: {
                    args: AuditLogGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AuditLogGroupByOutputType>[];
                };
                update: {
                    args: AuditLogUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>;
                };
                updateMany: {
                    args: AuditLogUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: AuditLogUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>[];
                };
                upsert: {
                    args: AuditLogUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$AuditLogPayload>;
                };
            };
            payload: $AuditLogPayload<ExtArgs>;
        };
        Permission: {
            fields: PermissionFieldRefs;
            operations: {
                aggregate: {
                    args: PermissionAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregatePermission>;
                };
                count: {
                    args: PermissionCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<PermissionCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: PermissionCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>;
                };
                createMany: {
                    args: PermissionCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: PermissionCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>[];
                };
                delete: {
                    args: PermissionDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>;
                };
                deleteMany: {
                    args: PermissionDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: PermissionFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload> | null;
                };
                findFirstOrThrow: {
                    args: PermissionFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>;
                };
                findMany: {
                    args: PermissionFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>[];
                };
                findUnique: {
                    args: PermissionFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload> | null;
                };
                findUniqueOrThrow: {
                    args: PermissionFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>;
                };
                groupBy: {
                    args: PermissionGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<PermissionGroupByOutputType>[];
                };
                update: {
                    args: PermissionUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>;
                };
                updateMany: {
                    args: PermissionUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: PermissionUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>[];
                };
                upsert: {
                    args: PermissionUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$PermissionPayload>;
                };
            };
            payload: $PermissionPayload<ExtArgs>;
        };
        Resource: {
            fields: ResourceFieldRefs;
            operations: {
                aggregate: {
                    args: ResourceAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateResource>;
                };
                count: {
                    args: ResourceCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<ResourceCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: ResourceCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>;
                };
                createMany: {
                    args: ResourceCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: ResourceCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>[];
                };
                delete: {
                    args: ResourceDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>;
                };
                deleteMany: {
                    args: ResourceDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: ResourceFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload> | null;
                };
                findFirstOrThrow: {
                    args: ResourceFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>;
                };
                findMany: {
                    args: ResourceFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>[];
                };
                findUnique: {
                    args: ResourceFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload> | null;
                };
                findUniqueOrThrow: {
                    args: ResourceFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>;
                };
                groupBy: {
                    args: ResourceGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<ResourceGroupByOutputType>[];
                };
                update: {
                    args: ResourceUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>;
                };
                updateMany: {
                    args: ResourceUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: ResourceUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>[];
                };
                upsert: {
                    args: ResourceUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$ResourcePayload>;
                };
            };
            payload: $ResourcePayload<ExtArgs>;
        };
        Role: {
            fields: RoleFieldRefs;
            operations: {
                aggregate: {
                    args: RoleAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateRole>;
                };
                count: {
                    args: RoleCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<RoleCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: RoleCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>;
                };
                createMany: {
                    args: RoleCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: RoleCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>[];
                };
                delete: {
                    args: RoleDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>;
                };
                deleteMany: {
                    args: RoleDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: RoleFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload> | null;
                };
                findFirstOrThrow: {
                    args: RoleFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>;
                };
                findMany: {
                    args: RoleFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>[];
                };
                findUnique: {
                    args: RoleFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: RoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>;
                };
                groupBy: {
                    args: RoleGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<RoleGroupByOutputType>[];
                };
                update: {
                    args: RoleUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>;
                };
                updateMany: {
                    args: RoleUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: RoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>[];
                };
                upsert: {
                    args: RoleUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePayload>;
                };
            };
            payload: $RolePayload<ExtArgs>;
        };
        RolePermissions: {
            fields: RolePermissionsFieldRefs;
            operations: {
                aggregate: {
                    args: RolePermissionsAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateRolePermissions>;
                };
                count: {
                    args: RolePermissionsCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<
                            RolePermissionsCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: RolePermissionsCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>;
                };
                createMany: {
                    args: RolePermissionsCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: RolePermissionsCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>[];
                };
                delete: {
                    args: RolePermissionsDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>;
                };
                deleteMany: {
                    args: RolePermissionsDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: RolePermissionsFindFirstArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: RolePermissionsFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>;
                };
                findMany: {
                    args: RolePermissionsFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>[];
                };
                findUnique: {
                    args: RolePermissionsFindUniqueArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: RolePermissionsFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>;
                };
                groupBy: {
                    args: RolePermissionsGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<RolePermissionsGroupByOutputType>[];
                };
                update: {
                    args: RolePermissionsUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>;
                };
                updateMany: {
                    args: RolePermissionsUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: RolePermissionsUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>[];
                };
                upsert: {
                    args: RolePermissionsUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$RolePermissionsPayload>;
                };
            };
            payload: $RolePermissionsPayload<ExtArgs>;
        };
        User: {
            fields: UserFieldRefs;
            operations: {
                aggregate: {
                    args: UserAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateUser>;
                };
                count: {
                    args: UserCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<UserCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: UserCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>;
                };
                createMany: {
                    args: UserCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: UserCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>[];
                };
                delete: {
                    args: UserDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>;
                };
                deleteMany: {
                    args: UserDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: UserFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>;
                };
                findMany: {
                    args: UserFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>[];
                };
                findUnique: {
                    args: UserFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>;
                };
                groupBy: {
                    args: UserGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<UserGroupByOutputType>[];
                };
                update: {
                    args: UserUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>;
                };
                updateMany: {
                    args: UserUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>[];
                };
                upsert: {
                    args: UserUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserPayload>;
                };
            };
            payload: $UserPayload<ExtArgs>;
        };
        UserRole: {
            fields: UserRoleFieldRefs;
            operations: {
                aggregate: {
                    args: UserRoleAggregateArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<AggregateUserRole>;
                };
                count: {
                    args: UserRoleCountArgs<ExtArgs>;
                    result:
                        | runtime.Types.Utils.Optional<UserRoleCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: UserRoleCreateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>;
                };
                createMany: {
                    args: UserRoleCreateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                createManyAndReturn: {
                    args: UserRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>[];
                };
                delete: {
                    args: UserRoleDeleteArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>;
                };
                deleteMany: {
                    args: UserRoleDeleteManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                findFirst: {
                    args: UserRoleFindFirstArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: UserRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>;
                };
                findMany: {
                    args: UserRoleFindManyArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>[];
                };
                findUnique: {
                    args: UserRoleFindUniqueArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>;
                };
                groupBy: {
                    args: UserRoleGroupByArgs<ExtArgs>;
                    result: runtime.Types.Utils.Optional<UserRoleGroupByOutputType>[];
                };
                update: {
                    args: UserRoleUpdateArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>;
                };
                updateMany: {
                    args: UserRoleUpdateManyArgs<ExtArgs>;
                    result: Prisma.BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>[];
                };
                upsert: {
                    args: UserRoleUpsertArgs<ExtArgs>;
                    result: runtime.Types.Utils.PayloadToResult<$UserRolePayload>;
                };
            };
            payload: $UserRolePayload<ExtArgs>;
        };
    };
} & {
    other: {
        operations: {
            $executeRaw: {
                args: [query: TemplateStringsArray | Prisma.Sql, values: any[]];
                result: any;
            };
            $executeRawUnsafe: { args: [query: string, values: any[]]; result: any };
            $queryRaw: {
                args: [query: TemplateStringsArray | Prisma.Sql, values: any[]];
                result: any;
            };
            $queryRawUnsafe: { args: [query: string, values: any[]]; result: any };
        };
        payload: any;
    };
}