Type Alias TypeMap<ExtArgs, GlobalOmitOptions>

TypeMap: {
    globalOmitOptions: { omit: GlobalOmitOptions };
    meta: {
        modelProps:
            | "guilds"
            | "guildCommandManger"
            | "buildInCommands"
            | "guildComponentManager"
            | "guildInteractionPermissions"
            | "guildAutoDeletes"
            | "guildAutoPublish"
            | "guildAutoReacts"
            | "guildAutoRoles"
            | "moderationScout"
            | "moderationScoutCases"
            | "moderationScoutForms"
            | "moderationScoutFormsData"
            | "moderationScoutUserAppeals"
            | "moderationScoutReportModalData"
            | "moderationScoutReports"
            | "guildModeration"
            | "guildUserModerationSettingBan"
            | "guildUserModerationSettingUnban"
            | "guildUserModerationSettinKick"
            | "guildUserModerationSettingWarn"
            | "guildUserModerationSettingUnwarn"
            | "guildUserModerationSettingMute"
            | "guildUserModerationSettingUnmute"
            | "guildUserModeration"
            | "guildDisBotAutoModeration"
            | "guildDisBotAutoModerationMessages"
            | "guildDisBotAutoModerationMentions"
            | "guildDisBotAutoModerationAttachments"
            | "guildDisBotAutoModerationEmojis"
            | "guildDisBotAutoModerationBlockedWords"
            | "guildDisBotAutoModerationBlockLinks"
            | "guildDisBotAutoModerationBlockInvites"
            | "guildChannelLinks"
            | "syncedChannelLinkMessages"
            | "discordGuildAddon"
            | "giveaways"
            | "tempVoices"
            | "tempVoiceChannels"
            | "guildLeaveSetup"
            | "leaveImageData"
            | "guildWelcomeSetup"
            | "welcomeImageData"
            | "guildLogging"
            | "guildLogs"
            | "messageTemplates"
            | "guildReactionRoles"
            | "reactionRoleSelectmenu"
            | "reactionRoleButton"
            | "guildSecurity"
            | "verificationGates"
            | "verificationGatesPermission"
            | "guildSpotifyNotifications"
            | "tags"
            | "polls"
            | "pollOptions"
            | "pollAnswers"
            | "ticketSetups"
            | "ticketModalData"
            | "ticketPermissions"
            | "tickets"
            | "ticketFeedback"
            | "guildFeatureToggles"
            | "guildTwitchNotifications"
            | "guildYoutubeNotifications"
            | "levelSettings"
            | "xPDrops"
            | "xPStreaks"
            | "levelRoles"
            | "levels"
            | "users"
            | "apis"
            | "guildBackups"
            | "vanitys"
            | "vanityEmbed"
            | "vanityEmbedAuthor"
            | "vanityAnalytic"
            | "vanityAnalyticsLatest30Day"
            | "disBot";
        txIsolationLevel: Prisma.TransactionIsolationLevel;
    };
    model: {
        Apis: {
            fields: ApisFieldRefs;
            operations: {
                aggregate: {
                    args: ApisAggregateArgs<ExtArgs>;
                    result: Optional<AggregateApis>;
                };
                count: {
                    args: ApisCountArgs<ExtArgs>;
                    result: Optional<ApisCountAggregateOutputType> | number;
                };
                create: {
                    args: ApisCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>;
                };
                createMany: { args: ApisCreateManyArgs<ExtArgs>; result: BatchPayload };
                createManyAndReturn: {
                    args: ApisCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>[];
                };
                delete: {
                    args: ApisDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>;
                };
                deleteMany: { args: ApisDeleteManyArgs<ExtArgs>; result: BatchPayload };
                findFirst: {
                    args: ApisFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload> | null;
                };
                findFirstOrThrow: {
                    args: ApisFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>;
                };
                findMany: {
                    args: ApisFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>[];
                };
                findUnique: {
                    args: ApisFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ApisFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>;
                };
                groupBy: {
                    args: ApisGroupByArgs<ExtArgs>;
                    result: Optional<ApisGroupByOutputType>[];
                };
                update: {
                    args: ApisUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>;
                };
                updateMany: { args: ApisUpdateManyArgs<ExtArgs>; result: BatchPayload };
                updateManyAndReturn: {
                    args: ApisUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>[];
                };
                upsert: {
                    args: ApisUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ApisPayload>;
                };
            };
            payload: $ApisPayload<ExtArgs>;
        };
        BuildInCommands: {
            fields: BuildInCommandsFieldRefs;
            operations: {
                aggregate: {
                    args: BuildInCommandsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateBuildInCommands>;
                };
                count: {
                    args: BuildInCommandsCountArgs<ExtArgs>;
                    result: Optional<BuildInCommandsCountAggregateOutputType> | number;
                };
                create: {
                    args: BuildInCommandsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>;
                };
                createMany: {
                    args: BuildInCommandsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: BuildInCommandsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>[];
                };
                delete: {
                    args: BuildInCommandsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>;
                };
                deleteMany: {
                    args: BuildInCommandsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: BuildInCommandsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload> | null;
                };
                findFirstOrThrow: {
                    args: BuildInCommandsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>;
                };
                findMany: {
                    args: BuildInCommandsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>[];
                };
                findUnique: {
                    args: BuildInCommandsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: BuildInCommandsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>;
                };
                groupBy: {
                    args: BuildInCommandsGroupByArgs<ExtArgs>;
                    result: Optional<BuildInCommandsGroupByOutputType>[];
                };
                update: {
                    args: BuildInCommandsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>;
                };
                updateMany: {
                    args: BuildInCommandsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: BuildInCommandsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>[];
                };
                upsert: {
                    args: BuildInCommandsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$BuildInCommandsPayload>;
                };
            };
            payload: $BuildInCommandsPayload<ExtArgs>;
        };
        DisBot: {
            fields: DisBotFieldRefs;
            operations: {
                aggregate: {
                    args: DisBotAggregateArgs<ExtArgs>;
                    result: Optional<AggregateDisBot>;
                };
                count: {
                    args: DisBotCountArgs<ExtArgs>;
                    result: Optional<DisBotCountAggregateOutputType> | number;
                };
                create: {
                    args: DisBotCreateArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>;
                };
                createMany: {
                    args: DisBotCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: DisBotCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>[];
                };
                delete: {
                    args: DisBotDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>;
                };
                deleteMany: {
                    args: DisBotDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: DisBotFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload> | null;
                };
                findFirstOrThrow: {
                    args: DisBotFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>;
                };
                findMany: {
                    args: DisBotFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>[];
                };
                findUnique: {
                    args: DisBotFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload> | null;
                };
                findUniqueOrThrow: {
                    args: DisBotFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>;
                };
                groupBy: {
                    args: DisBotGroupByArgs<ExtArgs>;
                    result: Optional<DisBotGroupByOutputType>[];
                };
                update: {
                    args: DisBotUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>;
                };
                updateMany: {
                    args: DisBotUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: DisBotUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>[];
                };
                upsert: {
                    args: DisBotUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$DisBotPayload>;
                };
            };
            payload: $DisBotPayload<ExtArgs>;
        };
        DiscordGuildAddon: {
            fields: DiscordGuildAddonFieldRefs;
            operations: {
                aggregate: {
                    args: DiscordGuildAddonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateDiscordGuildAddon>;
                };
                count: {
                    args: DiscordGuildAddonCountArgs<ExtArgs>;
                    result: Optional<DiscordGuildAddonCountAggregateOutputType> | number;
                };
                create: {
                    args: DiscordGuildAddonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>;
                };
                createMany: {
                    args: DiscordGuildAddonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: DiscordGuildAddonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>[];
                };
                delete: {
                    args: DiscordGuildAddonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>;
                };
                deleteMany: {
                    args: DiscordGuildAddonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: DiscordGuildAddonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload> | null;
                };
                findFirstOrThrow: {
                    args: DiscordGuildAddonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>;
                };
                findMany: {
                    args: DiscordGuildAddonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>[];
                };
                findUnique: {
                    args: DiscordGuildAddonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: DiscordGuildAddonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>;
                };
                groupBy: {
                    args: DiscordGuildAddonGroupByArgs<ExtArgs>;
                    result: Optional<DiscordGuildAddonGroupByOutputType>[];
                };
                update: {
                    args: DiscordGuildAddonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>;
                };
                updateMany: {
                    args: DiscordGuildAddonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: DiscordGuildAddonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>[];
                };
                upsert: {
                    args: DiscordGuildAddonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$DiscordGuildAddonPayload>;
                };
            };
            payload: $DiscordGuildAddonPayload<ExtArgs>;
        };
        Giveaways: {
            fields: GiveawaysFieldRefs;
            operations: {
                aggregate: {
                    args: GiveawaysAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGiveaways>;
                };
                count: {
                    args: GiveawaysCountArgs<ExtArgs>;
                    result: Optional<GiveawaysCountAggregateOutputType> | number;
                };
                create: {
                    args: GiveawaysCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>;
                };
                createMany: {
                    args: GiveawaysCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GiveawaysCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>[];
                };
                delete: {
                    args: GiveawaysDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>;
                };
                deleteMany: {
                    args: GiveawaysDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GiveawaysFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload> | null;
                };
                findFirstOrThrow: {
                    args: GiveawaysFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>;
                };
                findMany: {
                    args: GiveawaysFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>[];
                };
                findUnique: {
                    args: GiveawaysFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GiveawaysFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>;
                };
                groupBy: {
                    args: GiveawaysGroupByArgs<ExtArgs>;
                    result: Optional<GiveawaysGroupByOutputType>[];
                };
                update: {
                    args: GiveawaysUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>;
                };
                updateMany: {
                    args: GiveawaysUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GiveawaysUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>[];
                };
                upsert: {
                    args: GiveawaysUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GiveawaysPayload>;
                };
            };
            payload: $GiveawaysPayload<ExtArgs>;
        };
        GuildAutoDeletes: {
            fields: GuildAutoDeletesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAutoDeletesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildAutoDeletes>;
                };
                count: {
                    args: GuildAutoDeletesCountArgs<ExtArgs>;
                    result: Optional<GuildAutoDeletesCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildAutoDeletesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>;
                };
                createMany: {
                    args: GuildAutoDeletesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildAutoDeletesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>[];
                };
                delete: {
                    args: GuildAutoDeletesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>;
                };
                deleteMany: {
                    args: GuildAutoDeletesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildAutoDeletesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildAutoDeletesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>;
                };
                findMany: {
                    args: GuildAutoDeletesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>[];
                };
                findUnique: {
                    args: GuildAutoDeletesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildAutoDeletesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>;
                };
                groupBy: {
                    args: GuildAutoDeletesGroupByArgs<ExtArgs>;
                    result: Optional<GuildAutoDeletesGroupByOutputType>[];
                };
                update: {
                    args: GuildAutoDeletesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>;
                };
                updateMany: {
                    args: GuildAutoDeletesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildAutoDeletesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>[];
                };
                upsert: {
                    args: GuildAutoDeletesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoDeletesPayload>;
                };
            };
            payload: $GuildAutoDeletesPayload<ExtArgs>;
        };
        GuildAutoPublish: {
            fields: GuildAutoPublishFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAutoPublishAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildAutoPublish>;
                };
                count: {
                    args: GuildAutoPublishCountArgs<ExtArgs>;
                    result: Optional<GuildAutoPublishCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildAutoPublishCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>;
                };
                createMany: {
                    args: GuildAutoPublishCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildAutoPublishCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>[];
                };
                delete: {
                    args: GuildAutoPublishDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>;
                };
                deleteMany: {
                    args: GuildAutoPublishDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildAutoPublishFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildAutoPublishFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>;
                };
                findMany: {
                    args: GuildAutoPublishFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>[];
                };
                findUnique: {
                    args: GuildAutoPublishFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildAutoPublishFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>;
                };
                groupBy: {
                    args: GuildAutoPublishGroupByArgs<ExtArgs>;
                    result: Optional<GuildAutoPublishGroupByOutputType>[];
                };
                update: {
                    args: GuildAutoPublishUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>;
                };
                updateMany: {
                    args: GuildAutoPublishUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildAutoPublishUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>[];
                };
                upsert: {
                    args: GuildAutoPublishUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoPublishPayload>;
                };
            };
            payload: $GuildAutoPublishPayload<ExtArgs>;
        };
        GuildAutoReacts: {
            fields: GuildAutoReactsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAutoReactsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildAutoReacts>;
                };
                count: {
                    args: GuildAutoReactsCountArgs<ExtArgs>;
                    result: Optional<GuildAutoReactsCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildAutoReactsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>;
                };
                createMany: {
                    args: GuildAutoReactsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildAutoReactsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>[];
                };
                delete: {
                    args: GuildAutoReactsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>;
                };
                deleteMany: {
                    args: GuildAutoReactsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildAutoReactsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildAutoReactsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>;
                };
                findMany: {
                    args: GuildAutoReactsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>[];
                };
                findUnique: {
                    args: GuildAutoReactsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildAutoReactsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>;
                };
                groupBy: {
                    args: GuildAutoReactsGroupByArgs<ExtArgs>;
                    result: Optional<GuildAutoReactsGroupByOutputType>[];
                };
                update: {
                    args: GuildAutoReactsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>;
                };
                updateMany: {
                    args: GuildAutoReactsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildAutoReactsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>[];
                };
                upsert: {
                    args: GuildAutoReactsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoReactsPayload>;
                };
            };
            payload: $GuildAutoReactsPayload<ExtArgs>;
        };
        GuildAutoRoles: {
            fields: GuildAutoRolesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAutoRolesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildAutoRoles>;
                };
                count: {
                    args: GuildAutoRolesCountArgs<ExtArgs>;
                    result: Optional<GuildAutoRolesCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildAutoRolesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>;
                };
                createMany: {
                    args: GuildAutoRolesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildAutoRolesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>[];
                };
                delete: {
                    args: GuildAutoRolesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>;
                };
                deleteMany: {
                    args: GuildAutoRolesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildAutoRolesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildAutoRolesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>;
                };
                findMany: {
                    args: GuildAutoRolesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>[];
                };
                findUnique: {
                    args: GuildAutoRolesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildAutoRolesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>;
                };
                groupBy: {
                    args: GuildAutoRolesGroupByArgs<ExtArgs>;
                    result: Optional<GuildAutoRolesGroupByOutputType>[];
                };
                update: {
                    args: GuildAutoRolesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>;
                };
                updateMany: {
                    args: GuildAutoRolesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildAutoRolesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>[];
                };
                upsert: {
                    args: GuildAutoRolesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoRolesPayload>;
                };
            };
            payload: $GuildAutoRolesPayload<ExtArgs>;
        };
        GuildBackups: {
            fields: GuildBackupsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildBackupsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildBackups>;
                };
                count: {
                    args: GuildBackupsCountArgs<ExtArgs>;
                    result: Optional<GuildBackupsCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildBackupsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>;
                };
                createMany: {
                    args: GuildBackupsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildBackupsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>[];
                };
                delete: {
                    args: GuildBackupsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>;
                };
                deleteMany: {
                    args: GuildBackupsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildBackupsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildBackupsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>;
                };
                findMany: {
                    args: GuildBackupsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>[];
                };
                findUnique: {
                    args: GuildBackupsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildBackupsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>;
                };
                groupBy: {
                    args: GuildBackupsGroupByArgs<ExtArgs>;
                    result: Optional<GuildBackupsGroupByOutputType>[];
                };
                update: {
                    args: GuildBackupsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>;
                };
                updateMany: {
                    args: GuildBackupsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildBackupsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>[];
                };
                upsert: {
                    args: GuildBackupsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildBackupsPayload>;
                };
            };
            payload: $GuildBackupsPayload<ExtArgs>;
        };
        GuildChannelLinks: {
            fields: GuildChannelLinksFieldRefs;
            operations: {
                aggregate: {
                    args: GuildChannelLinksAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildChannelLinks>;
                };
                count: {
                    args: GuildChannelLinksCountArgs<ExtArgs>;
                    result: Optional<GuildChannelLinksCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildChannelLinksCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>;
                };
                createMany: {
                    args: GuildChannelLinksCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildChannelLinksCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>[];
                };
                delete: {
                    args: GuildChannelLinksDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>;
                };
                deleteMany: {
                    args: GuildChannelLinksDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildChannelLinksFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildChannelLinksFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>;
                };
                findMany: {
                    args: GuildChannelLinksFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>[];
                };
                findUnique: {
                    args: GuildChannelLinksFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildChannelLinksFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>;
                };
                groupBy: {
                    args: GuildChannelLinksGroupByArgs<ExtArgs>;
                    result: Optional<GuildChannelLinksGroupByOutputType>[];
                };
                update: {
                    args: GuildChannelLinksUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>;
                };
                updateMany: {
                    args: GuildChannelLinksUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildChannelLinksUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>[];
                };
                upsert: {
                    args: GuildChannelLinksUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildChannelLinksPayload>;
                };
            };
            payload: $GuildChannelLinksPayload<ExtArgs>;
        };
        GuildCommandManger: {
            fields: GuildCommandMangerFieldRefs;
            operations: {
                aggregate: {
                    args: GuildCommandMangerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildCommandManger>;
                };
                count: {
                    args: GuildCommandMangerCountArgs<ExtArgs>;
                    result: Optional<GuildCommandMangerCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildCommandMangerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>;
                };
                createMany: {
                    args: GuildCommandMangerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildCommandMangerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>[];
                };
                delete: {
                    args: GuildCommandMangerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>;
                };
                deleteMany: {
                    args: GuildCommandMangerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildCommandMangerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildCommandMangerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>;
                };
                findMany: {
                    args: GuildCommandMangerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>[];
                };
                findUnique: {
                    args: GuildCommandMangerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildCommandMangerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>;
                };
                groupBy: {
                    args: GuildCommandMangerGroupByArgs<ExtArgs>;
                    result: Optional<GuildCommandMangerGroupByOutputType>[];
                };
                update: {
                    args: GuildCommandMangerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>;
                };
                updateMany: {
                    args: GuildCommandMangerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildCommandMangerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>[];
                };
                upsert: {
                    args: GuildCommandMangerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCommandMangerPayload>;
                };
            };
            payload: $GuildCommandMangerPayload<ExtArgs>;
        };
        GuildComponentManager: {
            fields: GuildComponentManagerFieldRefs;
            operations: {
                aggregate: {
                    args: GuildComponentManagerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildComponentManager>;
                };
                count: {
                    args: GuildComponentManagerCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildComponentManagerCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildComponentManagerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>;
                };
                createMany: {
                    args: GuildComponentManagerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildComponentManagerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>[];
                };
                delete: {
                    args: GuildComponentManagerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>;
                };
                deleteMany: {
                    args: GuildComponentManagerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildComponentManagerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildComponentManagerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>;
                };
                findMany: {
                    args: GuildComponentManagerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>[];
                };
                findUnique: {
                    args: GuildComponentManagerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildComponentManagerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>;
                };
                groupBy: {
                    args: GuildComponentManagerGroupByArgs<ExtArgs>;
                    result: Optional<GuildComponentManagerGroupByOutputType>[];
                };
                update: {
                    args: GuildComponentManagerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>;
                };
                updateMany: {
                    args: GuildComponentManagerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildComponentManagerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>[];
                };
                upsert: {
                    args: GuildComponentManagerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildComponentManagerPayload>;
                };
            };
            payload: $GuildComponentManagerPayload<ExtArgs>;
        };
        GuildDisBotAutoModeration: {
            fields: GuildDisBotAutoModerationFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModeration>;
                };
                count: {
                    args: GuildDisBotAutoModerationCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildDisBotAutoModerationCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisBotAutoModerationGroupByOutputType>[];
                };
                update: {
                    args: GuildDisBotAutoModerationUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationAttachments: {
            fields: GuildDisBotAutoModerationAttachmentsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationAttachmentsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationAttachments>;
                };
                count: {
                    args: GuildDisBotAutoModerationAttachmentsCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildDisBotAutoModerationAttachmentsCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationAttachmentsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationAttachmentsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationAttachmentsCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationAttachmentsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationAttachmentsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationAttachmentsFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationAttachmentsFindFirstOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationAttachmentsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationAttachmentsFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationAttachmentsFindUniqueOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationAttachmentsGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisBotAutoModerationAttachmentsGroupByOutputType>[];
                };
                update: {
                    args: GuildDisBotAutoModerationAttachmentsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationAttachmentsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationAttachmentsUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationAttachmentsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationAttachmentsPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationAttachmentsPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationBlockedWords: {
            fields: GuildDisBotAutoModerationBlockedWordsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationBlockedWordsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationBlockedWords>;
                };
                count: {
                    args: GuildDisBotAutoModerationBlockedWordsCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildDisBotAutoModerationBlockedWordsCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationBlockedWordsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationBlockedWordsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationBlockedWordsCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationBlockedWordsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationBlockedWordsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationBlockedWordsFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationBlockedWordsFindFirstOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationBlockedWordsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationBlockedWordsFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationBlockedWordsFindUniqueOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationBlockedWordsGroupByArgs<ExtArgs>;
                    result: Optional<
                        GuildDisBotAutoModerationBlockedWordsGroupByOutputType,
                    >[];
                };
                update: {
                    args: GuildDisBotAutoModerationBlockedWordsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationBlockedWordsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationBlockedWordsUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationBlockedWordsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockedWordsPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationBlockedWordsPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationBlockInvites: {
            fields: GuildDisBotAutoModerationBlockInvitesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationBlockInvitesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationBlockInvites>;
                };
                count: {
                    args: GuildDisBotAutoModerationBlockInvitesCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildDisBotAutoModerationBlockInvitesCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationBlockInvitesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationBlockInvitesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationBlockInvitesCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationBlockInvitesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationBlockInvitesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationBlockInvitesFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationBlockInvitesFindFirstOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationBlockInvitesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationBlockInvitesFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationBlockInvitesFindUniqueOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationBlockInvitesGroupByArgs<ExtArgs>;
                    result: Optional<
                        GuildDisBotAutoModerationBlockInvitesGroupByOutputType,
                    >[];
                };
                update: {
                    args: GuildDisBotAutoModerationBlockInvitesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationBlockInvitesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationBlockInvitesUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationBlockInvitesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockInvitesPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationBlockInvitesPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationBlockLinks: {
            fields: GuildDisBotAutoModerationBlockLinksFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationBlockLinksAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationBlockLinks>;
                };
                count: {
                    args: GuildDisBotAutoModerationBlockLinksCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildDisBotAutoModerationBlockLinksCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationBlockLinksCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationBlockLinksCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationBlockLinksCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationBlockLinksDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationBlockLinksDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationBlockLinksFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationBlockLinksFindFirstOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationBlockLinksFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationBlockLinksFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationBlockLinksFindUniqueOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationBlockLinksGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisBotAutoModerationBlockLinksGroupByOutputType>[];
                };
                update: {
                    args: GuildDisBotAutoModerationBlockLinksUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationBlockLinksUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationBlockLinksUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationBlockLinksUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationBlockLinksPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationBlockLinksPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationEmojis: {
            fields: GuildDisBotAutoModerationEmojisFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationEmojisAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationEmojis>;
                };
                count: {
                    args: GuildDisBotAutoModerationEmojisCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildDisBotAutoModerationEmojisCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationEmojisCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationEmojisCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationEmojisCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationEmojisDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationEmojisDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationEmojisFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationEmojisFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationEmojisFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationEmojisFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationEmojisFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationEmojisGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisBotAutoModerationEmojisGroupByOutputType>[];
                };
                update: {
                    args: GuildDisBotAutoModerationEmojisUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationEmojisUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationEmojisUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationEmojisUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationEmojisPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationEmojisPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationMentions: {
            fields: GuildDisBotAutoModerationMentionsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationMentionsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationMentions>;
                };
                count: {
                    args: GuildDisBotAutoModerationMentionsCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildDisBotAutoModerationMentionsCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationMentionsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationMentionsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationMentionsCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationMentionsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationMentionsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationMentionsFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationMentionsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationMentionsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationMentionsFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationMentionsFindUniqueOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationMentionsGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisBotAutoModerationMentionsGroupByOutputType>[];
                };
                update: {
                    args: GuildDisBotAutoModerationMentionsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationMentionsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationMentionsUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationMentionsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMentionsPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationMentionsPayload<ExtArgs>;
        };
        GuildDisBotAutoModerationMessages: {
            fields: GuildDisBotAutoModerationMessagesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisBotAutoModerationMessagesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisBotAutoModerationMessages>;
                };
                count: {
                    args: GuildDisBotAutoModerationMessagesCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildDisBotAutoModerationMessagesCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildDisBotAutoModerationMessagesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>;
                };
                createMany: {
                    args: GuildDisBotAutoModerationMessagesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisBotAutoModerationMessagesCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>[];
                };
                delete: {
                    args: GuildDisBotAutoModerationMessagesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>;
                };
                deleteMany: {
                    args: GuildDisBotAutoModerationMessagesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisBotAutoModerationMessagesFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildDisBotAutoModerationMessagesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>;
                };
                findMany: {
                    args: GuildDisBotAutoModerationMessagesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>[];
                };
                findUnique: {
                    args: GuildDisBotAutoModerationMessagesFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisBotAutoModerationMessagesFindUniqueOrThrowArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>;
                };
                groupBy: {
                    args: GuildDisBotAutoModerationMessagesGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisBotAutoModerationMessagesGroupByOutputType>[];
                };
                update: {
                    args: GuildDisBotAutoModerationMessagesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>;
                };
                updateMany: {
                    args: GuildDisBotAutoModerationMessagesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisBotAutoModerationMessagesUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>[];
                };
                upsert: {
                    args: GuildDisBotAutoModerationMessagesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisBotAutoModerationMessagesPayload>;
                };
            };
            payload: $GuildDisBotAutoModerationMessagesPayload<ExtArgs>;
        };
        GuildFeatureToggles: {
            fields: GuildFeatureTogglesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildFeatureTogglesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildFeatureToggles>;
                };
                count: {
                    args: GuildFeatureTogglesCountArgs<ExtArgs>;
                    result: Optional<GuildFeatureTogglesCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildFeatureTogglesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>;
                };
                createMany: {
                    args: GuildFeatureTogglesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildFeatureTogglesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>[];
                };
                delete: {
                    args: GuildFeatureTogglesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>;
                };
                deleteMany: {
                    args: GuildFeatureTogglesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildFeatureTogglesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildFeatureTogglesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>;
                };
                findMany: {
                    args: GuildFeatureTogglesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>[];
                };
                findUnique: {
                    args: GuildFeatureTogglesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildFeatureTogglesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>;
                };
                groupBy: {
                    args: GuildFeatureTogglesGroupByArgs<ExtArgs>;
                    result: Optional<GuildFeatureTogglesGroupByOutputType>[];
                };
                update: {
                    args: GuildFeatureTogglesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>;
                };
                updateMany: {
                    args: GuildFeatureTogglesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildFeatureTogglesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>[];
                };
                upsert: {
                    args: GuildFeatureTogglesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildFeatureTogglesPayload>;
                };
            };
            payload: $GuildFeatureTogglesPayload<ExtArgs>;
        };
        GuildInteractionPermissions: {
            fields: GuildInteractionPermissionsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildInteractionPermissionsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildInteractionPermissions>;
                };
                count: {
                    args: GuildInteractionPermissionsCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildInteractionPermissionsCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildInteractionPermissionsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>;
                };
                createMany: {
                    args: GuildInteractionPermissionsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildInteractionPermissionsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>[];
                };
                delete: {
                    args: GuildInteractionPermissionsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>;
                };
                deleteMany: {
                    args: GuildInteractionPermissionsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildInteractionPermissionsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildInteractionPermissionsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>;
                };
                findMany: {
                    args: GuildInteractionPermissionsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>[];
                };
                findUnique: {
                    args: GuildInteractionPermissionsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildInteractionPermissionsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>;
                };
                groupBy: {
                    args: GuildInteractionPermissionsGroupByArgs<ExtArgs>;
                    result: Optional<GuildInteractionPermissionsGroupByOutputType>[];
                };
                update: {
                    args: GuildInteractionPermissionsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>;
                };
                updateMany: {
                    args: GuildInteractionPermissionsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildInteractionPermissionsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>[];
                };
                upsert: {
                    args: GuildInteractionPermissionsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildInteractionPermissionsPayload>;
                };
            };
            payload: $GuildInteractionPermissionsPayload<ExtArgs>;
        };
        GuildLeaveSetup: {
            fields: GuildLeaveSetupFieldRefs;
            operations: {
                aggregate: {
                    args: GuildLeaveSetupAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildLeaveSetup>;
                };
                count: {
                    args: GuildLeaveSetupCountArgs<ExtArgs>;
                    result: Optional<GuildLeaveSetupCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildLeaveSetupCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>;
                };
                createMany: {
                    args: GuildLeaveSetupCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildLeaveSetupCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>[];
                };
                delete: {
                    args: GuildLeaveSetupDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>;
                };
                deleteMany: {
                    args: GuildLeaveSetupDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildLeaveSetupFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildLeaveSetupFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>;
                };
                findMany: {
                    args: GuildLeaveSetupFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>[];
                };
                findUnique: {
                    args: GuildLeaveSetupFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildLeaveSetupFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>;
                };
                groupBy: {
                    args: GuildLeaveSetupGroupByArgs<ExtArgs>;
                    result: Optional<GuildLeaveSetupGroupByOutputType>[];
                };
                update: {
                    args: GuildLeaveSetupUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>;
                };
                updateMany: {
                    args: GuildLeaveSetupUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildLeaveSetupUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>[];
                };
                upsert: {
                    args: GuildLeaveSetupUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLeaveSetupPayload>;
                };
            };
            payload: $GuildLeaveSetupPayload<ExtArgs>;
        };
        GuildLogging: {
            fields: GuildLoggingFieldRefs;
            operations: {
                aggregate: {
                    args: GuildLoggingAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildLogging>;
                };
                count: {
                    args: GuildLoggingCountArgs<ExtArgs>;
                    result: Optional<GuildLoggingCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildLoggingCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>;
                };
                createMany: {
                    args: GuildLoggingCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildLoggingCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>[];
                };
                delete: {
                    args: GuildLoggingDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>;
                };
                deleteMany: {
                    args: GuildLoggingDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildLoggingFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildLoggingFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>;
                };
                findMany: {
                    args: GuildLoggingFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>[];
                };
                findUnique: {
                    args: GuildLoggingFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildLoggingFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>;
                };
                groupBy: {
                    args: GuildLoggingGroupByArgs<ExtArgs>;
                    result: Optional<GuildLoggingGroupByOutputType>[];
                };
                update: {
                    args: GuildLoggingUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>;
                };
                updateMany: {
                    args: GuildLoggingUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildLoggingUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>[];
                };
                upsert: {
                    args: GuildLoggingUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLoggingPayload>;
                };
            };
            payload: $GuildLoggingPayload<ExtArgs>;
        };
        GuildLogs: {
            fields: GuildLogsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildLogsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildLogs>;
                };
                count: {
                    args: GuildLogsCountArgs<ExtArgs>;
                    result: Optional<GuildLogsCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildLogsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>;
                };
                createMany: {
                    args: GuildLogsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildLogsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>[];
                };
                delete: {
                    args: GuildLogsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>;
                };
                deleteMany: {
                    args: GuildLogsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildLogsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildLogsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>;
                };
                findMany: {
                    args: GuildLogsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>[];
                };
                findUnique: {
                    args: GuildLogsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildLogsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>;
                };
                groupBy: {
                    args: GuildLogsGroupByArgs<ExtArgs>;
                    result: Optional<GuildLogsGroupByOutputType>[];
                };
                update: {
                    args: GuildLogsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>;
                };
                updateMany: {
                    args: GuildLogsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildLogsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>[];
                };
                upsert: {
                    args: GuildLogsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLogsPayload>;
                };
            };
            payload: $GuildLogsPayload<ExtArgs>;
        };
        GuildModeration: {
            fields: GuildModerationFieldRefs;
            operations: {
                aggregate: {
                    args: GuildModerationAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildModeration>;
                };
                count: {
                    args: GuildModerationCountArgs<ExtArgs>;
                    result: Optional<GuildModerationCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildModerationCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>;
                };
                createMany: {
                    args: GuildModerationCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildModerationCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>[];
                };
                delete: {
                    args: GuildModerationDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>;
                };
                deleteMany: {
                    args: GuildModerationDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildModerationFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildModerationFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>;
                };
                findMany: {
                    args: GuildModerationFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>[];
                };
                findUnique: {
                    args: GuildModerationFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildModerationFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>;
                };
                groupBy: {
                    args: GuildModerationGroupByArgs<ExtArgs>;
                    result: Optional<GuildModerationGroupByOutputType>[];
                };
                update: {
                    args: GuildModerationUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>;
                };
                updateMany: {
                    args: GuildModerationUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildModerationUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>[];
                };
                upsert: {
                    args: GuildModerationUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildModerationPayload>;
                };
            };
            payload: $GuildModerationPayload<ExtArgs>;
        };
        GuildReactionRoles: {
            fields: GuildReactionRolesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildReactionRolesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildReactionRoles>;
                };
                count: {
                    args: GuildReactionRolesCountArgs<ExtArgs>;
                    result: Optional<GuildReactionRolesCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildReactionRolesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>;
                };
                createMany: {
                    args: GuildReactionRolesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildReactionRolesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>[];
                };
                delete: {
                    args: GuildReactionRolesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>;
                };
                deleteMany: {
                    args: GuildReactionRolesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildReactionRolesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildReactionRolesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>;
                };
                findMany: {
                    args: GuildReactionRolesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>[];
                };
                findUnique: {
                    args: GuildReactionRolesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildReactionRolesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>;
                };
                groupBy: {
                    args: GuildReactionRolesGroupByArgs<ExtArgs>;
                    result: Optional<GuildReactionRolesGroupByOutputType>[];
                };
                update: {
                    args: GuildReactionRolesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>;
                };
                updateMany: {
                    args: GuildReactionRolesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildReactionRolesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>[];
                };
                upsert: {
                    args: GuildReactionRolesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildReactionRolesPayload>;
                };
            };
            payload: $GuildReactionRolesPayload<ExtArgs>;
        };
        Guilds: {
            fields: GuildsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuilds>;
                };
                count: {
                    args: GuildsCountArgs<ExtArgs>;
                    result: Optional<GuildsCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>;
                };
                createMany: {
                    args: GuildsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>[];
                };
                delete: {
                    args: GuildsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>;
                };
                deleteMany: {
                    args: GuildsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>;
                };
                findMany: {
                    args: GuildsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>[];
                };
                findUnique: {
                    args: GuildsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>;
                };
                groupBy: {
                    args: GuildsGroupByArgs<ExtArgs>;
                    result: Optional<GuildsGroupByOutputType>[];
                };
                update: {
                    args: GuildsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>;
                };
                updateMany: {
                    args: GuildsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>[];
                };
                upsert: {
                    args: GuildsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildsPayload>;
                };
            };
            payload: $GuildsPayload<ExtArgs>;
        };
        GuildSecurity: {
            fields: GuildSecurityFieldRefs;
            operations: {
                aggregate: {
                    args: GuildSecurityAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildSecurity>;
                };
                count: {
                    args: GuildSecurityCountArgs<ExtArgs>;
                    result: Optional<GuildSecurityCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildSecurityCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>;
                };
                createMany: {
                    args: GuildSecurityCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildSecurityCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>[];
                };
                delete: {
                    args: GuildSecurityDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>;
                };
                deleteMany: {
                    args: GuildSecurityDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildSecurityFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildSecurityFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>;
                };
                findMany: {
                    args: GuildSecurityFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>[];
                };
                findUnique: {
                    args: GuildSecurityFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildSecurityFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>;
                };
                groupBy: {
                    args: GuildSecurityGroupByArgs<ExtArgs>;
                    result: Optional<GuildSecurityGroupByOutputType>[];
                };
                update: {
                    args: GuildSecurityUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>;
                };
                updateMany: {
                    args: GuildSecurityUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildSecurityUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>[];
                };
                upsert: {
                    args: GuildSecurityUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSecurityPayload>;
                };
            };
            payload: $GuildSecurityPayload<ExtArgs>;
        };
        GuildSpotifyNotifications: {
            fields: GuildSpotifyNotificationsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildSpotifyNotificationsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildSpotifyNotifications>;
                };
                count: {
                    args: GuildSpotifyNotificationsCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildSpotifyNotificationsCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildSpotifyNotificationsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>;
                };
                createMany: {
                    args: GuildSpotifyNotificationsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildSpotifyNotificationsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>[];
                };
                delete: {
                    args: GuildSpotifyNotificationsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>;
                };
                deleteMany: {
                    args: GuildSpotifyNotificationsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildSpotifyNotificationsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildSpotifyNotificationsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>;
                };
                findMany: {
                    args: GuildSpotifyNotificationsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>[];
                };
                findUnique: {
                    args: GuildSpotifyNotificationsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildSpotifyNotificationsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>;
                };
                groupBy: {
                    args: GuildSpotifyNotificationsGroupByArgs<ExtArgs>;
                    result: Optional<GuildSpotifyNotificationsGroupByOutputType>[];
                };
                update: {
                    args: GuildSpotifyNotificationsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>;
                };
                updateMany: {
                    args: GuildSpotifyNotificationsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildSpotifyNotificationsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>[];
                };
                upsert: {
                    args: GuildSpotifyNotificationsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSpotifyNotificationsPayload>;
                };
            };
            payload: $GuildSpotifyNotificationsPayload<ExtArgs>;
        };
        GuildTwitchNotifications: {
            fields: GuildTwitchNotificationsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildTwitchNotificationsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildTwitchNotifications>;
                };
                count: {
                    args: GuildTwitchNotificationsCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildTwitchNotificationsCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildTwitchNotificationsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>;
                };
                createMany: {
                    args: GuildTwitchNotificationsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildTwitchNotificationsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>[];
                };
                delete: {
                    args: GuildTwitchNotificationsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>;
                };
                deleteMany: {
                    args: GuildTwitchNotificationsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildTwitchNotificationsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildTwitchNotificationsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>;
                };
                findMany: {
                    args: GuildTwitchNotificationsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>[];
                };
                findUnique: {
                    args: GuildTwitchNotificationsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildTwitchNotificationsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>;
                };
                groupBy: {
                    args: GuildTwitchNotificationsGroupByArgs<ExtArgs>;
                    result: Optional<GuildTwitchNotificationsGroupByOutputType>[];
                };
                update: {
                    args: GuildTwitchNotificationsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>;
                };
                updateMany: {
                    args: GuildTwitchNotificationsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildTwitchNotificationsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>[];
                };
                upsert: {
                    args: GuildTwitchNotificationsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildTwitchNotificationsPayload>;
                };
            };
            payload: $GuildTwitchNotificationsPayload<ExtArgs>;
        };
        GuildUserModeration: {
            fields: GuildUserModerationFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModeration>;
                };
                count: {
                    args: GuildUserModerationCountArgs<ExtArgs>;
                    result: Optional<GuildUserModerationCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildUserModerationCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>;
                };
                createMany: {
                    args: GuildUserModerationCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>[];
                };
                delete: {
                    args: GuildUserModerationDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>;
                };
                deleteMany: {
                    args: GuildUserModerationDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>;
                };
                findMany: {
                    args: GuildUserModerationFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>[];
                };
                findUnique: {
                    args: GuildUserModerationFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>;
                };
                groupBy: {
                    args: GuildUserModerationGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>;
                };
                updateMany: {
                    args: GuildUserModerationUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>[];
                };
                upsert: {
                    args: GuildUserModerationUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationPayload>;
                };
            };
            payload: $GuildUserModerationPayload<ExtArgs>;
        };
        GuildUserModerationSettingBan: {
            fields: GuildUserModerationSettingBanFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettingBanAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettingBan>;
                };
                count: {
                    args: GuildUserModerationSettingBanCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildUserModerationSettingBanCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildUserModerationSettingBanCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>;
                };
                createMany: {
                    args: GuildUserModerationSettingBanCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettingBanCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>[];
                };
                delete: {
                    args: GuildUserModerationSettingBanDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettingBanDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettingBanFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettingBanFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>;
                };
                findMany: {
                    args: GuildUserModerationSettingBanFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettingBanFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettingBanFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettingBanGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettingBanGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettingBanUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettingBanUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettingBanUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettingBanUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingBanPayload>;
                };
            };
            payload: $GuildUserModerationSettingBanPayload<ExtArgs>;
        };
        GuildUserModerationSettingMute: {
            fields: GuildUserModerationSettingMuteFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettingMuteAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettingMute>;
                };
                count: {
                    args: GuildUserModerationSettingMuteCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildUserModerationSettingMuteCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildUserModerationSettingMuteCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>;
                };
                createMany: {
                    args: GuildUserModerationSettingMuteCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettingMuteCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>[];
                };
                delete: {
                    args: GuildUserModerationSettingMuteDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettingMuteDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettingMuteFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettingMuteFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>;
                };
                findMany: {
                    args: GuildUserModerationSettingMuteFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettingMuteFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettingMuteFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettingMuteGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettingMuteGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettingMuteUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettingMuteUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettingMuteUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettingMuteUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingMutePayload>;
                };
            };
            payload: $GuildUserModerationSettingMutePayload<ExtArgs>;
        };
        GuildUserModerationSettingUnban: {
            fields: GuildUserModerationSettingUnbanFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettingUnbanAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettingUnban>;
                };
                count: {
                    args: GuildUserModerationSettingUnbanCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildUserModerationSettingUnbanCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildUserModerationSettingUnbanCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>;
                };
                createMany: {
                    args: GuildUserModerationSettingUnbanCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettingUnbanCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>[];
                };
                delete: {
                    args: GuildUserModerationSettingUnbanDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettingUnbanDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettingUnbanFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettingUnbanFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>;
                };
                findMany: {
                    args: GuildUserModerationSettingUnbanFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettingUnbanFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettingUnbanFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettingUnbanGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettingUnbanGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettingUnbanUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettingUnbanUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettingUnbanUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettingUnbanUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnbanPayload>;
                };
            };
            payload: $GuildUserModerationSettingUnbanPayload<ExtArgs>;
        };
        GuildUserModerationSettingUnmute: {
            fields: GuildUserModerationSettingUnmuteFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettingUnmuteAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettingUnmute>;
                };
                count: {
                    args: GuildUserModerationSettingUnmuteCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildUserModerationSettingUnmuteCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildUserModerationSettingUnmuteCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>;
                };
                createMany: {
                    args: GuildUserModerationSettingUnmuteCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettingUnmuteCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>[];
                };
                delete: {
                    args: GuildUserModerationSettingUnmuteDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettingUnmuteDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettingUnmuteFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildUserModerationSettingUnmutePayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettingUnmuteFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>;
                };
                findMany: {
                    args: GuildUserModerationSettingUnmuteFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettingUnmuteFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildUserModerationSettingUnmutePayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettingUnmuteFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettingUnmuteGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettingUnmuteGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettingUnmuteUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettingUnmuteUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettingUnmuteUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettingUnmuteUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnmutePayload>;
                };
            };
            payload: $GuildUserModerationSettingUnmutePayload<ExtArgs>;
        };
        GuildUserModerationSettingUnwarn: {
            fields: GuildUserModerationSettingUnwarnFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettingUnwarnAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettingUnwarn>;
                };
                count: {
                    args: GuildUserModerationSettingUnwarnCountArgs<ExtArgs>;
                    result:
                        | Optional<
                            GuildUserModerationSettingUnwarnCountAggregateOutputType,
                        >
                        | number;
                };
                create: {
                    args: GuildUserModerationSettingUnwarnCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>;
                };
                createMany: {
                    args: GuildUserModerationSettingUnwarnCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettingUnwarnCreateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>[];
                };
                delete: {
                    args: GuildUserModerationSettingUnwarnDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettingUnwarnDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettingUnwarnFindFirstArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildUserModerationSettingUnwarnPayload>
                        | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettingUnwarnFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>;
                };
                findMany: {
                    args: GuildUserModerationSettingUnwarnFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettingUnwarnFindUniqueArgs<ExtArgs>;
                    result:
                        | PayloadToResult<$GuildUserModerationSettingUnwarnPayload>
                        | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettingUnwarnFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettingUnwarnGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettingUnwarnGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettingUnwarnUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettingUnwarnUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettingUnwarnUpdateManyAndReturnArgs<
                        ExtArgs,
                    >;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettingUnwarnUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingUnwarnPayload>;
                };
            };
            payload: $GuildUserModerationSettingUnwarnPayload<ExtArgs>;
        };
        GuildUserModerationSettingWarn: {
            fields: GuildUserModerationSettingWarnFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettingWarnAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettingWarn>;
                };
                count: {
                    args: GuildUserModerationSettingWarnCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildUserModerationSettingWarnCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildUserModerationSettingWarnCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>;
                };
                createMany: {
                    args: GuildUserModerationSettingWarnCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettingWarnCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>[];
                };
                delete: {
                    args: GuildUserModerationSettingWarnDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettingWarnDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettingWarnFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettingWarnFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>;
                };
                findMany: {
                    args: GuildUserModerationSettingWarnFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettingWarnFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettingWarnFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettingWarnGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettingWarnGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettingWarnUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettingWarnUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettingWarnUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettingWarnUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettingWarnPayload>;
                };
            };
            payload: $GuildUserModerationSettingWarnPayload<ExtArgs>;
        };
        GuildUserModerationSettinKick: {
            fields: GuildUserModerationSettinKickFieldRefs;
            operations: {
                aggregate: {
                    args: GuildUserModerationSettinKickAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildUserModerationSettinKick>;
                };
                count: {
                    args: GuildUserModerationSettinKickCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildUserModerationSettinKickCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildUserModerationSettinKickCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>;
                };
                createMany: {
                    args: GuildUserModerationSettinKickCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildUserModerationSettinKickCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>[];
                };
                delete: {
                    args: GuildUserModerationSettinKickDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>;
                };
                deleteMany: {
                    args: GuildUserModerationSettinKickDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildUserModerationSettinKickFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildUserModerationSettinKickFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>;
                };
                findMany: {
                    args: GuildUserModerationSettinKickFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>[];
                };
                findUnique: {
                    args: GuildUserModerationSettinKickFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildUserModerationSettinKickFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>;
                };
                groupBy: {
                    args: GuildUserModerationSettinKickGroupByArgs<ExtArgs>;
                    result: Optional<GuildUserModerationSettinKickGroupByOutputType>[];
                };
                update: {
                    args: GuildUserModerationSettinKickUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>;
                };
                updateMany: {
                    args: GuildUserModerationSettinKickUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUserModerationSettinKickUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>[];
                };
                upsert: {
                    args: GuildUserModerationSettinKickUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildUserModerationSettinKickPayload>;
                };
            };
            payload: $GuildUserModerationSettinKickPayload<ExtArgs>;
        };
        GuildWelcomeSetup: {
            fields: GuildWelcomeSetupFieldRefs;
            operations: {
                aggregate: {
                    args: GuildWelcomeSetupAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildWelcomeSetup>;
                };
                count: {
                    args: GuildWelcomeSetupCountArgs<ExtArgs>;
                    result: Optional<GuildWelcomeSetupCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildWelcomeSetupCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>;
                };
                createMany: {
                    args: GuildWelcomeSetupCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildWelcomeSetupCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>[];
                };
                delete: {
                    args: GuildWelcomeSetupDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>;
                };
                deleteMany: {
                    args: GuildWelcomeSetupDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildWelcomeSetupFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildWelcomeSetupFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>;
                };
                findMany: {
                    args: GuildWelcomeSetupFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>[];
                };
                findUnique: {
                    args: GuildWelcomeSetupFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildWelcomeSetupFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>;
                };
                groupBy: {
                    args: GuildWelcomeSetupGroupByArgs<ExtArgs>;
                    result: Optional<GuildWelcomeSetupGroupByOutputType>[];
                };
                update: {
                    args: GuildWelcomeSetupUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>;
                };
                updateMany: {
                    args: GuildWelcomeSetupUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildWelcomeSetupUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>[];
                };
                upsert: {
                    args: GuildWelcomeSetupUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildWelcomeSetupPayload>;
                };
            };
            payload: $GuildWelcomeSetupPayload<ExtArgs>;
        };
        GuildYoutubeNotifications: {
            fields: GuildYoutubeNotificationsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildYoutubeNotificationsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildYoutubeNotifications>;
                };
                count: {
                    args: GuildYoutubeNotificationsCountArgs<ExtArgs>;
                    result:
                        | Optional<GuildYoutubeNotificationsCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: GuildYoutubeNotificationsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>;
                };
                createMany: {
                    args: GuildYoutubeNotificationsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildYoutubeNotificationsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>[];
                };
                delete: {
                    args: GuildYoutubeNotificationsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>;
                };
                deleteMany: {
                    args: GuildYoutubeNotificationsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildYoutubeNotificationsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildYoutubeNotificationsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>;
                };
                findMany: {
                    args: GuildYoutubeNotificationsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>[];
                };
                findUnique: {
                    args: GuildYoutubeNotificationsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildYoutubeNotificationsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>;
                };
                groupBy: {
                    args: GuildYoutubeNotificationsGroupByArgs<ExtArgs>;
                    result: Optional<GuildYoutubeNotificationsGroupByOutputType>[];
                };
                update: {
                    args: GuildYoutubeNotificationsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>;
                };
                updateMany: {
                    args: GuildYoutubeNotificationsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildYoutubeNotificationsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>[];
                };
                upsert: {
                    args: GuildYoutubeNotificationsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildYoutubeNotificationsPayload>;
                };
            };
            payload: $GuildYoutubeNotificationsPayload<ExtArgs>;
        };
        LeaveImageData: {
            fields: LeaveImageDataFieldRefs;
            operations: {
                aggregate: {
                    args: LeaveImageDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateLeaveImageData>;
                };
                count: {
                    args: LeaveImageDataCountArgs<ExtArgs>;
                    result: Optional<LeaveImageDataCountAggregateOutputType> | number;
                };
                create: {
                    args: LeaveImageDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>;
                };
                createMany: {
                    args: LeaveImageDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: LeaveImageDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>[];
                };
                delete: {
                    args: LeaveImageDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>;
                };
                deleteMany: {
                    args: LeaveImageDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: LeaveImageDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: LeaveImageDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>;
                };
                findMany: {
                    args: LeaveImageDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>[];
                };
                findUnique: {
                    args: LeaveImageDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: LeaveImageDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>;
                };
                groupBy: {
                    args: LeaveImageDataGroupByArgs<ExtArgs>;
                    result: Optional<LeaveImageDataGroupByOutputType>[];
                };
                update: {
                    args: LeaveImageDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>;
                };
                updateMany: {
                    args: LeaveImageDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: LeaveImageDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>[];
                };
                upsert: {
                    args: LeaveImageDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$LeaveImageDataPayload>;
                };
            };
            payload: $LeaveImageDataPayload<ExtArgs>;
        };
        LevelRoles: {
            fields: LevelRolesFieldRefs;
            operations: {
                aggregate: {
                    args: LevelRolesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateLevelRoles>;
                };
                count: {
                    args: LevelRolesCountArgs<ExtArgs>;
                    result: Optional<LevelRolesCountAggregateOutputType> | number;
                };
                create: {
                    args: LevelRolesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>;
                };
                createMany: {
                    args: LevelRolesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: LevelRolesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>[];
                };
                delete: {
                    args: LevelRolesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>;
                };
                deleteMany: {
                    args: LevelRolesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: LevelRolesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload> | null;
                };
                findFirstOrThrow: {
                    args: LevelRolesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>;
                };
                findMany: {
                    args: LevelRolesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>[];
                };
                findUnique: {
                    args: LevelRolesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: LevelRolesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>;
                };
                groupBy: {
                    args: LevelRolesGroupByArgs<ExtArgs>;
                    result: Optional<LevelRolesGroupByOutputType>[];
                };
                update: {
                    args: LevelRolesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>;
                };
                updateMany: {
                    args: LevelRolesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: LevelRolesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>[];
                };
                upsert: {
                    args: LevelRolesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$LevelRolesPayload>;
                };
            };
            payload: $LevelRolesPayload<ExtArgs>;
        };
        Levels: {
            fields: LevelsFieldRefs;
            operations: {
                aggregate: {
                    args: LevelsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateLevels>;
                };
                count: {
                    args: LevelsCountArgs<ExtArgs>;
                    result: Optional<LevelsCountAggregateOutputType> | number;
                };
                create: {
                    args: LevelsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>;
                };
                createMany: {
                    args: LevelsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: LevelsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>[];
                };
                delete: {
                    args: LevelsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>;
                };
                deleteMany: {
                    args: LevelsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: LevelsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload> | null;
                };
                findFirstOrThrow: {
                    args: LevelsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>;
                };
                findMany: {
                    args: LevelsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>[];
                };
                findUnique: {
                    args: LevelsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: LevelsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>;
                };
                groupBy: {
                    args: LevelsGroupByArgs<ExtArgs>;
                    result: Optional<LevelsGroupByOutputType>[];
                };
                update: {
                    args: LevelsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>;
                };
                updateMany: {
                    args: LevelsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: LevelsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>[];
                };
                upsert: {
                    args: LevelsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$LevelsPayload>;
                };
            };
            payload: $LevelsPayload<ExtArgs>;
        };
        LevelSettings: {
            fields: LevelSettingsFieldRefs;
            operations: {
                aggregate: {
                    args: LevelSettingsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateLevelSettings>;
                };
                count: {
                    args: LevelSettingsCountArgs<ExtArgs>;
                    result: Optional<LevelSettingsCountAggregateOutputType> | number;
                };
                create: {
                    args: LevelSettingsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>;
                };
                createMany: {
                    args: LevelSettingsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: LevelSettingsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>[];
                };
                delete: {
                    args: LevelSettingsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>;
                };
                deleteMany: {
                    args: LevelSettingsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: LevelSettingsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload> | null;
                };
                findFirstOrThrow: {
                    args: LevelSettingsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>;
                };
                findMany: {
                    args: LevelSettingsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>[];
                };
                findUnique: {
                    args: LevelSettingsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: LevelSettingsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>;
                };
                groupBy: {
                    args: LevelSettingsGroupByArgs<ExtArgs>;
                    result: Optional<LevelSettingsGroupByOutputType>[];
                };
                update: {
                    args: LevelSettingsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>;
                };
                updateMany: {
                    args: LevelSettingsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: LevelSettingsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>[];
                };
                upsert: {
                    args: LevelSettingsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$LevelSettingsPayload>;
                };
            };
            payload: $LevelSettingsPayload<ExtArgs>;
        };
        MessageTemplates: {
            fields: MessageTemplatesFieldRefs;
            operations: {
                aggregate: {
                    args: MessageTemplatesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateMessageTemplates>;
                };
                count: {
                    args: MessageTemplatesCountArgs<ExtArgs>;
                    result: Optional<MessageTemplatesCountAggregateOutputType> | number;
                };
                create: {
                    args: MessageTemplatesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>;
                };
                createMany: {
                    args: MessageTemplatesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: MessageTemplatesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>[];
                };
                delete: {
                    args: MessageTemplatesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>;
                };
                deleteMany: {
                    args: MessageTemplatesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: MessageTemplatesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload> | null;
                };
                findFirstOrThrow: {
                    args: MessageTemplatesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>;
                };
                findMany: {
                    args: MessageTemplatesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>[];
                };
                findUnique: {
                    args: MessageTemplatesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: MessageTemplatesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>;
                };
                groupBy: {
                    args: MessageTemplatesGroupByArgs<ExtArgs>;
                    result: Optional<MessageTemplatesGroupByOutputType>[];
                };
                update: {
                    args: MessageTemplatesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>;
                };
                updateMany: {
                    args: MessageTemplatesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: MessageTemplatesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>[];
                };
                upsert: {
                    args: MessageTemplatesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$MessageTemplatesPayload>;
                };
            };
            payload: $MessageTemplatesPayload<ExtArgs>;
        };
        ModerationScout: {
            fields: ModerationScoutFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScout>;
                };
                count: {
                    args: ModerationScoutCountArgs<ExtArgs>;
                    result: Optional<ModerationScoutCountAggregateOutputType> | number;
                };
                create: {
                    args: ModerationScoutCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>;
                };
                createMany: {
                    args: ModerationScoutCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>[];
                };
                delete: {
                    args: ModerationScoutDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>;
                };
                deleteMany: {
                    args: ModerationScoutDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>;
                };
                findMany: {
                    args: ModerationScoutFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>[];
                };
                findUnique: {
                    args: ModerationScoutFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>;
                };
                groupBy: {
                    args: ModerationScoutGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>;
                };
                updateMany: {
                    args: ModerationScoutUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>[];
                };
                upsert: {
                    args: ModerationScoutUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutPayload>;
                };
            };
            payload: $ModerationScoutPayload<ExtArgs>;
        };
        ModerationScoutCases: {
            fields: ModerationScoutCasesFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutCasesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScoutCases>;
                };
                count: {
                    args: ModerationScoutCasesCountArgs<ExtArgs>;
                    result: Optional<ModerationScoutCasesCountAggregateOutputType> | number;
                };
                create: {
                    args: ModerationScoutCasesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>;
                };
                createMany: {
                    args: ModerationScoutCasesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutCasesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>[];
                };
                delete: {
                    args: ModerationScoutCasesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>;
                };
                deleteMany: {
                    args: ModerationScoutCasesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutCasesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutCasesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>;
                };
                findMany: {
                    args: ModerationScoutCasesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>[];
                };
                findUnique: {
                    args: ModerationScoutCasesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutCasesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>;
                };
                groupBy: {
                    args: ModerationScoutCasesGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutCasesGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutCasesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>;
                };
                updateMany: {
                    args: ModerationScoutCasesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutCasesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>[];
                };
                upsert: {
                    args: ModerationScoutCasesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutCasesPayload>;
                };
            };
            payload: $ModerationScoutCasesPayload<ExtArgs>;
        };
        ModerationScoutForms: {
            fields: ModerationScoutFormsFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutFormsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScoutForms>;
                };
                count: {
                    args: ModerationScoutFormsCountArgs<ExtArgs>;
                    result: Optional<ModerationScoutFormsCountAggregateOutputType> | number;
                };
                create: {
                    args: ModerationScoutFormsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>;
                };
                createMany: {
                    args: ModerationScoutFormsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutFormsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>[];
                };
                delete: {
                    args: ModerationScoutFormsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>;
                };
                deleteMany: {
                    args: ModerationScoutFormsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutFormsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutFormsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>;
                };
                findMany: {
                    args: ModerationScoutFormsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>[];
                };
                findUnique: {
                    args: ModerationScoutFormsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutFormsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>;
                };
                groupBy: {
                    args: ModerationScoutFormsGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutFormsGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutFormsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>;
                };
                updateMany: {
                    args: ModerationScoutFormsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutFormsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>[];
                };
                upsert: {
                    args: ModerationScoutFormsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsPayload>;
                };
            };
            payload: $ModerationScoutFormsPayload<ExtArgs>;
        };
        ModerationScoutFormsData: {
            fields: ModerationScoutFormsDataFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutFormsDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScoutFormsData>;
                };
                count: {
                    args: ModerationScoutFormsDataCountArgs<ExtArgs>;
                    result:
                        | Optional<ModerationScoutFormsDataCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: ModerationScoutFormsDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>;
                };
                createMany: {
                    args: ModerationScoutFormsDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutFormsDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>[];
                };
                delete: {
                    args: ModerationScoutFormsDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>;
                };
                deleteMany: {
                    args: ModerationScoutFormsDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutFormsDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutFormsDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>;
                };
                findMany: {
                    args: ModerationScoutFormsDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>[];
                };
                findUnique: {
                    args: ModerationScoutFormsDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutFormsDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>;
                };
                groupBy: {
                    args: ModerationScoutFormsDataGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutFormsDataGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutFormsDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>;
                };
                updateMany: {
                    args: ModerationScoutFormsDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutFormsDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>[];
                };
                upsert: {
                    args: ModerationScoutFormsDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutFormsDataPayload>;
                };
            };
            payload: $ModerationScoutFormsDataPayload<ExtArgs>;
        };
        ModerationScoutReportModalData: {
            fields: ModerationScoutReportModalDataFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutReportModalDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScoutReportModalData>;
                };
                count: {
                    args: ModerationScoutReportModalDataCountArgs<ExtArgs>;
                    result:
                        | Optional<ModerationScoutReportModalDataCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: ModerationScoutReportModalDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>;
                };
                createMany: {
                    args: ModerationScoutReportModalDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutReportModalDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>[];
                };
                delete: {
                    args: ModerationScoutReportModalDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>;
                };
                deleteMany: {
                    args: ModerationScoutReportModalDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutReportModalDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutReportModalDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>;
                };
                findMany: {
                    args: ModerationScoutReportModalDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>[];
                };
                findUnique: {
                    args: ModerationScoutReportModalDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutReportModalDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>;
                };
                groupBy: {
                    args: ModerationScoutReportModalDataGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutReportModalDataGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutReportModalDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>;
                };
                updateMany: {
                    args: ModerationScoutReportModalDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutReportModalDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>[];
                };
                upsert: {
                    args: ModerationScoutReportModalDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportModalDataPayload>;
                };
            };
            payload: $ModerationScoutReportModalDataPayload<ExtArgs>;
        };
        ModerationScoutReports: {
            fields: ModerationScoutReportsFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutReportsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScoutReports>;
                };
                count: {
                    args: ModerationScoutReportsCountArgs<ExtArgs>;
                    result:
                        | Optional<ModerationScoutReportsCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: ModerationScoutReportsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>;
                };
                createMany: {
                    args: ModerationScoutReportsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutReportsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>[];
                };
                delete: {
                    args: ModerationScoutReportsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>;
                };
                deleteMany: {
                    args: ModerationScoutReportsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutReportsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutReportsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>;
                };
                findMany: {
                    args: ModerationScoutReportsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>[];
                };
                findUnique: {
                    args: ModerationScoutReportsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutReportsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>;
                };
                groupBy: {
                    args: ModerationScoutReportsGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutReportsGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutReportsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>;
                };
                updateMany: {
                    args: ModerationScoutReportsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutReportsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>[];
                };
                upsert: {
                    args: ModerationScoutReportsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutReportsPayload>;
                };
            };
            payload: $ModerationScoutReportsPayload<ExtArgs>;
        };
        ModerationScoutUserAppeals: {
            fields: ModerationScoutUserAppealsFieldRefs;
            operations: {
                aggregate: {
                    args: ModerationScoutUserAppealsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateModerationScoutUserAppeals>;
                };
                count: {
                    args: ModerationScoutUserAppealsCountArgs<ExtArgs>;
                    result:
                        | Optional<ModerationScoutUserAppealsCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: ModerationScoutUserAppealsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>;
                };
                createMany: {
                    args: ModerationScoutUserAppealsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ModerationScoutUserAppealsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>[];
                };
                delete: {
                    args: ModerationScoutUserAppealsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>;
                };
                deleteMany: {
                    args: ModerationScoutUserAppealsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ModerationScoutUserAppealsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload> | null;
                };
                findFirstOrThrow: {
                    args: ModerationScoutUserAppealsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>;
                };
                findMany: {
                    args: ModerationScoutUserAppealsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>[];
                };
                findUnique: {
                    args: ModerationScoutUserAppealsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ModerationScoutUserAppealsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>;
                };
                groupBy: {
                    args: ModerationScoutUserAppealsGroupByArgs<ExtArgs>;
                    result: Optional<ModerationScoutUserAppealsGroupByOutputType>[];
                };
                update: {
                    args: ModerationScoutUserAppealsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>;
                };
                updateMany: {
                    args: ModerationScoutUserAppealsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ModerationScoutUserAppealsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>[];
                };
                upsert: {
                    args: ModerationScoutUserAppealsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ModerationScoutUserAppealsPayload>;
                };
            };
            payload: $ModerationScoutUserAppealsPayload<ExtArgs>;
        };
        PollAnswers: {
            fields: PollAnswersFieldRefs;
            operations: {
                aggregate: {
                    args: PollAnswersAggregateArgs<ExtArgs>;
                    result: Optional<AggregatePollAnswers>;
                };
                count: {
                    args: PollAnswersCountArgs<ExtArgs>;
                    result: Optional<PollAnswersCountAggregateOutputType> | number;
                };
                create: {
                    args: PollAnswersCreateArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>;
                };
                createMany: {
                    args: PollAnswersCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: PollAnswersCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>[];
                };
                delete: {
                    args: PollAnswersDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>;
                };
                deleteMany: {
                    args: PollAnswersDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: PollAnswersFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload> | null;
                };
                findFirstOrThrow: {
                    args: PollAnswersFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>;
                };
                findMany: {
                    args: PollAnswersFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>[];
                };
                findUnique: {
                    args: PollAnswersFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload> | null;
                };
                findUniqueOrThrow: {
                    args: PollAnswersFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>;
                };
                groupBy: {
                    args: PollAnswersGroupByArgs<ExtArgs>;
                    result: Optional<PollAnswersGroupByOutputType>[];
                };
                update: {
                    args: PollAnswersUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>;
                };
                updateMany: {
                    args: PollAnswersUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: PollAnswersUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>[];
                };
                upsert: {
                    args: PollAnswersUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$PollAnswersPayload>;
                };
            };
            payload: $PollAnswersPayload<ExtArgs>;
        };
        PollOptions: {
            fields: PollOptionsFieldRefs;
            operations: {
                aggregate: {
                    args: PollOptionsAggregateArgs<ExtArgs>;
                    result: Optional<AggregatePollOptions>;
                };
                count: {
                    args: PollOptionsCountArgs<ExtArgs>;
                    result: Optional<PollOptionsCountAggregateOutputType> | number;
                };
                create: {
                    args: PollOptionsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>;
                };
                createMany: {
                    args: PollOptionsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: PollOptionsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>[];
                };
                delete: {
                    args: PollOptionsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>;
                };
                deleteMany: {
                    args: PollOptionsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: PollOptionsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload> | null;
                };
                findFirstOrThrow: {
                    args: PollOptionsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>;
                };
                findMany: {
                    args: PollOptionsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>[];
                };
                findUnique: {
                    args: PollOptionsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: PollOptionsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>;
                };
                groupBy: {
                    args: PollOptionsGroupByArgs<ExtArgs>;
                    result: Optional<PollOptionsGroupByOutputType>[];
                };
                update: {
                    args: PollOptionsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>;
                };
                updateMany: {
                    args: PollOptionsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: PollOptionsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>[];
                };
                upsert: {
                    args: PollOptionsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$PollOptionsPayload>;
                };
            };
            payload: $PollOptionsPayload<ExtArgs>;
        };
        Polls: {
            fields: PollsFieldRefs;
            operations: {
                aggregate: {
                    args: PollsAggregateArgs<ExtArgs>;
                    result: Optional<AggregatePolls>;
                };
                count: {
                    args: PollsCountArgs<ExtArgs>;
                    result: Optional<PollsCountAggregateOutputType> | number;
                };
                create: {
                    args: PollsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>;
                };
                createMany: { args: PollsCreateManyArgs<ExtArgs>; result: BatchPayload };
                createManyAndReturn: {
                    args: PollsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>[];
                };
                delete: {
                    args: PollsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>;
                };
                deleteMany: { args: PollsDeleteManyArgs<ExtArgs>; result: BatchPayload };
                findFirst: {
                    args: PollsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload> | null;
                };
                findFirstOrThrow: {
                    args: PollsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>;
                };
                findMany: {
                    args: PollsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>[];
                };
                findUnique: {
                    args: PollsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: PollsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>;
                };
                groupBy: {
                    args: PollsGroupByArgs<ExtArgs>;
                    result: Optional<PollsGroupByOutputType>[];
                };
                update: {
                    args: PollsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>;
                };
                updateMany: { args: PollsUpdateManyArgs<ExtArgs>; result: BatchPayload };
                updateManyAndReturn: {
                    args: PollsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>[];
                };
                upsert: {
                    args: PollsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$PollsPayload>;
                };
            };
            payload: $PollsPayload<ExtArgs>;
        };
        ReactionRoleButton: {
            fields: ReactionRoleButtonFieldRefs;
            operations: {
                aggregate: {
                    args: ReactionRoleButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateReactionRoleButton>;
                };
                count: {
                    args: ReactionRoleButtonCountArgs<ExtArgs>;
                    result: Optional<ReactionRoleButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: ReactionRoleButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>;
                };
                createMany: {
                    args: ReactionRoleButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ReactionRoleButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>[];
                };
                delete: {
                    args: ReactionRoleButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>;
                };
                deleteMany: {
                    args: ReactionRoleButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ReactionRoleButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: ReactionRoleButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>;
                };
                findMany: {
                    args: ReactionRoleButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>[];
                };
                findUnique: {
                    args: ReactionRoleButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ReactionRoleButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>;
                };
                groupBy: {
                    args: ReactionRoleButtonGroupByArgs<ExtArgs>;
                    result: Optional<ReactionRoleButtonGroupByOutputType>[];
                };
                update: {
                    args: ReactionRoleButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>;
                };
                updateMany: {
                    args: ReactionRoleButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ReactionRoleButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>[];
                };
                upsert: {
                    args: ReactionRoleButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleButtonPayload>;
                };
            };
            payload: $ReactionRoleButtonPayload<ExtArgs>;
        };
        ReactionRoleSelectmenu: {
            fields: ReactionRoleSelectmenuFieldRefs;
            operations: {
                aggregate: {
                    args: ReactionRoleSelectmenuAggregateArgs<ExtArgs>;
                    result: Optional<AggregateReactionRoleSelectmenu>;
                };
                count: {
                    args: ReactionRoleSelectmenuCountArgs<ExtArgs>;
                    result:
                        | Optional<ReactionRoleSelectmenuCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: ReactionRoleSelectmenuCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>;
                };
                createMany: {
                    args: ReactionRoleSelectmenuCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ReactionRoleSelectmenuCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>[];
                };
                delete: {
                    args: ReactionRoleSelectmenuDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>;
                };
                deleteMany: {
                    args: ReactionRoleSelectmenuDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ReactionRoleSelectmenuFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload> | null;
                };
                findFirstOrThrow: {
                    args: ReactionRoleSelectmenuFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>;
                };
                findMany: {
                    args: ReactionRoleSelectmenuFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>[];
                };
                findUnique: {
                    args: ReactionRoleSelectmenuFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ReactionRoleSelectmenuFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>;
                };
                groupBy: {
                    args: ReactionRoleSelectmenuGroupByArgs<ExtArgs>;
                    result: Optional<ReactionRoleSelectmenuGroupByOutputType>[];
                };
                update: {
                    args: ReactionRoleSelectmenuUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>;
                };
                updateMany: {
                    args: ReactionRoleSelectmenuUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ReactionRoleSelectmenuUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>[];
                };
                upsert: {
                    args: ReactionRoleSelectmenuUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ReactionRoleSelectmenuPayload>;
                };
            };
            payload: $ReactionRoleSelectmenuPayload<ExtArgs>;
        };
        SyncedChannelLinkMessages: {
            fields: SyncedChannelLinkMessagesFieldRefs;
            operations: {
                aggregate: {
                    args: SyncedChannelLinkMessagesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateSyncedChannelLinkMessages>;
                };
                count: {
                    args: SyncedChannelLinkMessagesCountArgs<ExtArgs>;
                    result:
                        | Optional<SyncedChannelLinkMessagesCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: SyncedChannelLinkMessagesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>;
                };
                createMany: {
                    args: SyncedChannelLinkMessagesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: SyncedChannelLinkMessagesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>[];
                };
                delete: {
                    args: SyncedChannelLinkMessagesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>;
                };
                deleteMany: {
                    args: SyncedChannelLinkMessagesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: SyncedChannelLinkMessagesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload> | null;
                };
                findFirstOrThrow: {
                    args: SyncedChannelLinkMessagesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>;
                };
                findMany: {
                    args: SyncedChannelLinkMessagesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>[];
                };
                findUnique: {
                    args: SyncedChannelLinkMessagesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: SyncedChannelLinkMessagesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>;
                };
                groupBy: {
                    args: SyncedChannelLinkMessagesGroupByArgs<ExtArgs>;
                    result: Optional<SyncedChannelLinkMessagesGroupByOutputType>[];
                };
                update: {
                    args: SyncedChannelLinkMessagesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>;
                };
                updateMany: {
                    args: SyncedChannelLinkMessagesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: SyncedChannelLinkMessagesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>[];
                };
                upsert: {
                    args: SyncedChannelLinkMessagesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$SyncedChannelLinkMessagesPayload>;
                };
            };
            payload: $SyncedChannelLinkMessagesPayload<ExtArgs>;
        };
        Tags: {
            fields: TagsFieldRefs;
            operations: {
                aggregate: {
                    args: TagsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTags>;
                };
                count: {
                    args: TagsCountArgs<ExtArgs>;
                    result: Optional<TagsCountAggregateOutputType> | number;
                };
                create: {
                    args: TagsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>;
                };
                createMany: { args: TagsCreateManyArgs<ExtArgs>; result: BatchPayload };
                createManyAndReturn: {
                    args: TagsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>[];
                };
                delete: {
                    args: TagsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>;
                };
                deleteMany: { args: TagsDeleteManyArgs<ExtArgs>; result: BatchPayload };
                findFirst: {
                    args: TagsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload> | null;
                };
                findFirstOrThrow: {
                    args: TagsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>;
                };
                findMany: {
                    args: TagsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>[];
                };
                findUnique: {
                    args: TagsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TagsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>;
                };
                groupBy: {
                    args: TagsGroupByArgs<ExtArgs>;
                    result: Optional<TagsGroupByOutputType>[];
                };
                update: {
                    args: TagsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>;
                };
                updateMany: { args: TagsUpdateManyArgs<ExtArgs>; result: BatchPayload };
                updateManyAndReturn: {
                    args: TagsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>[];
                };
                upsert: {
                    args: TagsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TagsPayload>;
                };
            };
            payload: $TagsPayload<ExtArgs>;
        };
        TempVoiceChannels: {
            fields: TempVoiceChannelsFieldRefs;
            operations: {
                aggregate: {
                    args: TempVoiceChannelsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTempVoiceChannels>;
                };
                count: {
                    args: TempVoiceChannelsCountArgs<ExtArgs>;
                    result: Optional<TempVoiceChannelsCountAggregateOutputType> | number;
                };
                create: {
                    args: TempVoiceChannelsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>;
                };
                createMany: {
                    args: TempVoiceChannelsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TempVoiceChannelsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>[];
                };
                delete: {
                    args: TempVoiceChannelsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>;
                };
                deleteMany: {
                    args: TempVoiceChannelsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TempVoiceChannelsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload> | null;
                };
                findFirstOrThrow: {
                    args: TempVoiceChannelsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>;
                };
                findMany: {
                    args: TempVoiceChannelsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>[];
                };
                findUnique: {
                    args: TempVoiceChannelsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TempVoiceChannelsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>;
                };
                groupBy: {
                    args: TempVoiceChannelsGroupByArgs<ExtArgs>;
                    result: Optional<TempVoiceChannelsGroupByOutputType>[];
                };
                update: {
                    args: TempVoiceChannelsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>;
                };
                updateMany: {
                    args: TempVoiceChannelsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TempVoiceChannelsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>[];
                };
                upsert: {
                    args: TempVoiceChannelsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoiceChannelsPayload>;
                };
            };
            payload: $TempVoiceChannelsPayload<ExtArgs>;
        };
        TempVoices: {
            fields: TempVoicesFieldRefs;
            operations: {
                aggregate: {
                    args: TempVoicesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTempVoices>;
                };
                count: {
                    args: TempVoicesCountArgs<ExtArgs>;
                    result: Optional<TempVoicesCountAggregateOutputType> | number;
                };
                create: {
                    args: TempVoicesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>;
                };
                createMany: {
                    args: TempVoicesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TempVoicesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>[];
                };
                delete: {
                    args: TempVoicesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>;
                };
                deleteMany: {
                    args: TempVoicesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TempVoicesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload> | null;
                };
                findFirstOrThrow: {
                    args: TempVoicesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>;
                };
                findMany: {
                    args: TempVoicesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>[];
                };
                findUnique: {
                    args: TempVoicesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TempVoicesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>;
                };
                groupBy: {
                    args: TempVoicesGroupByArgs<ExtArgs>;
                    result: Optional<TempVoicesGroupByOutputType>[];
                };
                update: {
                    args: TempVoicesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>;
                };
                updateMany: {
                    args: TempVoicesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TempVoicesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>[];
                };
                upsert: {
                    args: TempVoicesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TempVoicesPayload>;
                };
            };
            payload: $TempVoicesPayload<ExtArgs>;
        };
        TicketFeedback: {
            fields: TicketFeedbackFieldRefs;
            operations: {
                aggregate: {
                    args: TicketFeedbackAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTicketFeedback>;
                };
                count: {
                    args: TicketFeedbackCountArgs<ExtArgs>;
                    result: Optional<TicketFeedbackCountAggregateOutputType> | number;
                };
                create: {
                    args: TicketFeedbackCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>;
                };
                createMany: {
                    args: TicketFeedbackCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TicketFeedbackCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>[];
                };
                delete: {
                    args: TicketFeedbackDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>;
                };
                deleteMany: {
                    args: TicketFeedbackDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TicketFeedbackFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload> | null;
                };
                findFirstOrThrow: {
                    args: TicketFeedbackFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>;
                };
                findMany: {
                    args: TicketFeedbackFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>[];
                };
                findUnique: {
                    args: TicketFeedbackFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TicketFeedbackFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>;
                };
                groupBy: {
                    args: TicketFeedbackGroupByArgs<ExtArgs>;
                    result: Optional<TicketFeedbackGroupByOutputType>[];
                };
                update: {
                    args: TicketFeedbackUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>;
                };
                updateMany: {
                    args: TicketFeedbackUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TicketFeedbackUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>[];
                };
                upsert: {
                    args: TicketFeedbackUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TicketFeedbackPayload>;
                };
            };
            payload: $TicketFeedbackPayload<ExtArgs>;
        };
        TicketModalData: {
            fields: TicketModalDataFieldRefs;
            operations: {
                aggregate: {
                    args: TicketModalDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTicketModalData>;
                };
                count: {
                    args: TicketModalDataCountArgs<ExtArgs>;
                    result: Optional<TicketModalDataCountAggregateOutputType> | number;
                };
                create: {
                    args: TicketModalDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>;
                };
                createMany: {
                    args: TicketModalDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TicketModalDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>[];
                };
                delete: {
                    args: TicketModalDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>;
                };
                deleteMany: {
                    args: TicketModalDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TicketModalDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: TicketModalDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>;
                };
                findMany: {
                    args: TicketModalDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>[];
                };
                findUnique: {
                    args: TicketModalDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TicketModalDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>;
                };
                groupBy: {
                    args: TicketModalDataGroupByArgs<ExtArgs>;
                    result: Optional<TicketModalDataGroupByOutputType>[];
                };
                update: {
                    args: TicketModalDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>;
                };
                updateMany: {
                    args: TicketModalDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TicketModalDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>[];
                };
                upsert: {
                    args: TicketModalDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TicketModalDataPayload>;
                };
            };
            payload: $TicketModalDataPayload<ExtArgs>;
        };
        TicketPermissions: {
            fields: TicketPermissionsFieldRefs;
            operations: {
                aggregate: {
                    args: TicketPermissionsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTicketPermissions>;
                };
                count: {
                    args: TicketPermissionsCountArgs<ExtArgs>;
                    result: Optional<TicketPermissionsCountAggregateOutputType> | number;
                };
                create: {
                    args: TicketPermissionsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>;
                };
                createMany: {
                    args: TicketPermissionsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TicketPermissionsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>[];
                };
                delete: {
                    args: TicketPermissionsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>;
                };
                deleteMany: {
                    args: TicketPermissionsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TicketPermissionsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload> | null;
                };
                findFirstOrThrow: {
                    args: TicketPermissionsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>;
                };
                findMany: {
                    args: TicketPermissionsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>[];
                };
                findUnique: {
                    args: TicketPermissionsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TicketPermissionsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>;
                };
                groupBy: {
                    args: TicketPermissionsGroupByArgs<ExtArgs>;
                    result: Optional<TicketPermissionsGroupByOutputType>[];
                };
                update: {
                    args: TicketPermissionsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>;
                };
                updateMany: {
                    args: TicketPermissionsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TicketPermissionsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>[];
                };
                upsert: {
                    args: TicketPermissionsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TicketPermissionsPayload>;
                };
            };
            payload: $TicketPermissionsPayload<ExtArgs>;
        };
        Tickets: {
            fields: TicketsFieldRefs;
            operations: {
                aggregate: {
                    args: TicketsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTickets>;
                };
                count: {
                    args: TicketsCountArgs<ExtArgs>;
                    result: Optional<TicketsCountAggregateOutputType> | number;
                };
                create: {
                    args: TicketsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>;
                };
                createMany: {
                    args: TicketsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TicketsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>[];
                };
                delete: {
                    args: TicketsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>;
                };
                deleteMany: {
                    args: TicketsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TicketsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload> | null;
                };
                findFirstOrThrow: {
                    args: TicketsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>;
                };
                findMany: {
                    args: TicketsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>[];
                };
                findUnique: {
                    args: TicketsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TicketsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>;
                };
                groupBy: {
                    args: TicketsGroupByArgs<ExtArgs>;
                    result: Optional<TicketsGroupByOutputType>[];
                };
                update: {
                    args: TicketsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>;
                };
                updateMany: {
                    args: TicketsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TicketsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>[];
                };
                upsert: {
                    args: TicketsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TicketsPayload>;
                };
            };
            payload: $TicketsPayload<ExtArgs>;
        };
        TicketSetups: {
            fields: TicketSetupsFieldRefs;
            operations: {
                aggregate: {
                    args: TicketSetupsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTicketSetups>;
                };
                count: {
                    args: TicketSetupsCountArgs<ExtArgs>;
                    result: Optional<TicketSetupsCountAggregateOutputType> | number;
                };
                create: {
                    args: TicketSetupsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>;
                };
                createMany: {
                    args: TicketSetupsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TicketSetupsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>[];
                };
                delete: {
                    args: TicketSetupsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>;
                };
                deleteMany: {
                    args: TicketSetupsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TicketSetupsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload> | null;
                };
                findFirstOrThrow: {
                    args: TicketSetupsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>;
                };
                findMany: {
                    args: TicketSetupsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>[];
                };
                findUnique: {
                    args: TicketSetupsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TicketSetupsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>;
                };
                groupBy: {
                    args: TicketSetupsGroupByArgs<ExtArgs>;
                    result: Optional<TicketSetupsGroupByOutputType>[];
                };
                update: {
                    args: TicketSetupsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>;
                };
                updateMany: {
                    args: TicketSetupsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TicketSetupsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>[];
                };
                upsert: {
                    args: TicketSetupsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TicketSetupsPayload>;
                };
            };
            payload: $TicketSetupsPayload<ExtArgs>;
        };
        Users: {
            fields: UsersFieldRefs;
            operations: {
                aggregate: {
                    args: UsersAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUsers>;
                };
                count: {
                    args: UsersCountArgs<ExtArgs>;
                    result: Optional<UsersCountAggregateOutputType> | number;
                };
                create: {
                    args: UsersCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>;
                };
                createMany: { args: UsersCreateManyArgs<ExtArgs>; result: BatchPayload };
                createManyAndReturn: {
                    args: UsersCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>[];
                };
                delete: {
                    args: UsersDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>;
                };
                deleteMany: { args: UsersDeleteManyArgs<ExtArgs>; result: BatchPayload };
                findFirst: {
                    args: UsersFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload> | null;
                };
                findFirstOrThrow: {
                    args: UsersFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>;
                };
                findMany: {
                    args: UsersFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>[];
                };
                findUnique: {
                    args: UsersFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UsersFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>;
                };
                groupBy: {
                    args: UsersGroupByArgs<ExtArgs>;
                    result: Optional<UsersGroupByOutputType>[];
                };
                update: {
                    args: UsersUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>;
                };
                updateMany: { args: UsersUpdateManyArgs<ExtArgs>; result: BatchPayload };
                updateManyAndReturn: {
                    args: UsersUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>[];
                };
                upsert: {
                    args: UsersUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UsersPayload>;
                };
            };
            payload: $UsersPayload<ExtArgs>;
        };
        VanityAnalytic: {
            fields: VanityAnalyticFieldRefs;
            operations: {
                aggregate: {
                    args: VanityAnalyticAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVanityAnalytic>;
                };
                count: {
                    args: VanityAnalyticCountArgs<ExtArgs>;
                    result: Optional<VanityAnalyticCountAggregateOutputType> | number;
                };
                create: {
                    args: VanityAnalyticCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>;
                };
                createMany: {
                    args: VanityAnalyticCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VanityAnalyticCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>[];
                };
                delete: {
                    args: VanityAnalyticDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>;
                };
                deleteMany: {
                    args: VanityAnalyticDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VanityAnalyticFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload> | null;
                };
                findFirstOrThrow: {
                    args: VanityAnalyticFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>;
                };
                findMany: {
                    args: VanityAnalyticFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>[];
                };
                findUnique: {
                    args: VanityAnalyticFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VanityAnalyticFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>;
                };
                groupBy: {
                    args: VanityAnalyticGroupByArgs<ExtArgs>;
                    result: Optional<VanityAnalyticGroupByOutputType>[];
                };
                update: {
                    args: VanityAnalyticUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>;
                };
                updateMany: {
                    args: VanityAnalyticUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VanityAnalyticUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>[];
                };
                upsert: {
                    args: VanityAnalyticUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticPayload>;
                };
            };
            payload: $VanityAnalyticPayload<ExtArgs>;
        };
        VanityAnalyticsLatest30Day: {
            fields: VanityAnalyticsLatest30DayFieldRefs;
            operations: {
                aggregate: {
                    args: VanityAnalyticsLatest30DayAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVanityAnalyticsLatest30Day>;
                };
                count: {
                    args: VanityAnalyticsLatest30DayCountArgs<ExtArgs>;
                    result:
                        | Optional<VanityAnalyticsLatest30DayCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: VanityAnalyticsLatest30DayCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>;
                };
                createMany: {
                    args: VanityAnalyticsLatest30DayCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VanityAnalyticsLatest30DayCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>[];
                };
                delete: {
                    args: VanityAnalyticsLatest30DayDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>;
                };
                deleteMany: {
                    args: VanityAnalyticsLatest30DayDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VanityAnalyticsLatest30DayFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload> | null;
                };
                findFirstOrThrow: {
                    args: VanityAnalyticsLatest30DayFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>;
                };
                findMany: {
                    args: VanityAnalyticsLatest30DayFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>[];
                };
                findUnique: {
                    args: VanityAnalyticsLatest30DayFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VanityAnalyticsLatest30DayFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>;
                };
                groupBy: {
                    args: VanityAnalyticsLatest30DayGroupByArgs<ExtArgs>;
                    result: Optional<VanityAnalyticsLatest30DayGroupByOutputType>[];
                };
                update: {
                    args: VanityAnalyticsLatest30DayUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>;
                };
                updateMany: {
                    args: VanityAnalyticsLatest30DayUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VanityAnalyticsLatest30DayUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>[];
                };
                upsert: {
                    args: VanityAnalyticsLatest30DayUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VanityAnalyticsLatest30DayPayload>;
                };
            };
            payload: $VanityAnalyticsLatest30DayPayload<ExtArgs>;
        };
        VanityEmbed: {
            fields: VanityEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: VanityEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVanityEmbed>;
                };
                count: {
                    args: VanityEmbedCountArgs<ExtArgs>;
                    result: Optional<VanityEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: VanityEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>;
                };
                createMany: {
                    args: VanityEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VanityEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>[];
                };
                delete: {
                    args: VanityEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>;
                };
                deleteMany: {
                    args: VanityEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VanityEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: VanityEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>;
                };
                findMany: {
                    args: VanityEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>[];
                };
                findUnique: {
                    args: VanityEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VanityEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>;
                };
                groupBy: {
                    args: VanityEmbedGroupByArgs<ExtArgs>;
                    result: Optional<VanityEmbedGroupByOutputType>[];
                };
                update: {
                    args: VanityEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>;
                };
                updateMany: {
                    args: VanityEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VanityEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>[];
                };
                upsert: {
                    args: VanityEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedPayload>;
                };
            };
            payload: $VanityEmbedPayload<ExtArgs>;
        };
        VanityEmbedAuthor: {
            fields: VanityEmbedAuthorFieldRefs;
            operations: {
                aggregate: {
                    args: VanityEmbedAuthorAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVanityEmbedAuthor>;
                };
                count: {
                    args: VanityEmbedAuthorCountArgs<ExtArgs>;
                    result: Optional<VanityEmbedAuthorCountAggregateOutputType> | number;
                };
                create: {
                    args: VanityEmbedAuthorCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>;
                };
                createMany: {
                    args: VanityEmbedAuthorCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VanityEmbedAuthorCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>[];
                };
                delete: {
                    args: VanityEmbedAuthorDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>;
                };
                deleteMany: {
                    args: VanityEmbedAuthorDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VanityEmbedAuthorFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload> | null;
                };
                findFirstOrThrow: {
                    args: VanityEmbedAuthorFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>;
                };
                findMany: {
                    args: VanityEmbedAuthorFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>[];
                };
                findUnique: {
                    args: VanityEmbedAuthorFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VanityEmbedAuthorFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>;
                };
                groupBy: {
                    args: VanityEmbedAuthorGroupByArgs<ExtArgs>;
                    result: Optional<VanityEmbedAuthorGroupByOutputType>[];
                };
                update: {
                    args: VanityEmbedAuthorUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>;
                };
                updateMany: {
                    args: VanityEmbedAuthorUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VanityEmbedAuthorUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>[];
                };
                upsert: {
                    args: VanityEmbedAuthorUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VanityEmbedAuthorPayload>;
                };
            };
            payload: $VanityEmbedAuthorPayload<ExtArgs>;
        };
        Vanitys: {
            fields: VanitysFieldRefs;
            operations: {
                aggregate: {
                    args: VanitysAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVanitys>;
                };
                count: {
                    args: VanitysCountArgs<ExtArgs>;
                    result: Optional<VanitysCountAggregateOutputType> | number;
                };
                create: {
                    args: VanitysCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>;
                };
                createMany: {
                    args: VanitysCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VanitysCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>[];
                };
                delete: {
                    args: VanitysDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>;
                };
                deleteMany: {
                    args: VanitysDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VanitysFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload> | null;
                };
                findFirstOrThrow: {
                    args: VanitysFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>;
                };
                findMany: {
                    args: VanitysFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>[];
                };
                findUnique: {
                    args: VanitysFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VanitysFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>;
                };
                groupBy: {
                    args: VanitysGroupByArgs<ExtArgs>;
                    result: Optional<VanitysGroupByOutputType>[];
                };
                update: {
                    args: VanitysUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>;
                };
                updateMany: {
                    args: VanitysUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VanitysUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>[];
                };
                upsert: {
                    args: VanitysUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VanitysPayload>;
                };
            };
            payload: $VanitysPayload<ExtArgs>;
        };
        VerificationGates: {
            fields: VerificationGatesFieldRefs;
            operations: {
                aggregate: {
                    args: VerificationGatesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVerificationGates>;
                };
                count: {
                    args: VerificationGatesCountArgs<ExtArgs>;
                    result: Optional<VerificationGatesCountAggregateOutputType> | number;
                };
                create: {
                    args: VerificationGatesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>;
                };
                createMany: {
                    args: VerificationGatesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VerificationGatesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>[];
                };
                delete: {
                    args: VerificationGatesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>;
                };
                deleteMany: {
                    args: VerificationGatesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VerificationGatesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload> | null;
                };
                findFirstOrThrow: {
                    args: VerificationGatesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>;
                };
                findMany: {
                    args: VerificationGatesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>[];
                };
                findUnique: {
                    args: VerificationGatesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VerificationGatesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>;
                };
                groupBy: {
                    args: VerificationGatesGroupByArgs<ExtArgs>;
                    result: Optional<VerificationGatesGroupByOutputType>[];
                };
                update: {
                    args: VerificationGatesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>;
                };
                updateMany: {
                    args: VerificationGatesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VerificationGatesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>[];
                };
                upsert: {
                    args: VerificationGatesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPayload>;
                };
            };
            payload: $VerificationGatesPayload<ExtArgs>;
        };
        VerificationGatesPermission: {
            fields: VerificationGatesPermissionFieldRefs;
            operations: {
                aggregate: {
                    args: VerificationGatesPermissionAggregateArgs<ExtArgs>;
                    result: Optional<AggregateVerificationGatesPermission>;
                };
                count: {
                    args: VerificationGatesPermissionCountArgs<ExtArgs>;
                    result:
                        | Optional<VerificationGatesPermissionCountAggregateOutputType>
                        | number;
                };
                create: {
                    args: VerificationGatesPermissionCreateArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>;
                };
                createMany: {
                    args: VerificationGatesPermissionCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: VerificationGatesPermissionCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>[];
                };
                delete: {
                    args: VerificationGatesPermissionDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>;
                };
                deleteMany: {
                    args: VerificationGatesPermissionDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: VerificationGatesPermissionFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload> | null;
                };
                findFirstOrThrow: {
                    args: VerificationGatesPermissionFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>;
                };
                findMany: {
                    args: VerificationGatesPermissionFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>[];
                };
                findUnique: {
                    args: VerificationGatesPermissionFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload> | null;
                };
                findUniqueOrThrow: {
                    args: VerificationGatesPermissionFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>;
                };
                groupBy: {
                    args: VerificationGatesPermissionGroupByArgs<ExtArgs>;
                    result: Optional<VerificationGatesPermissionGroupByOutputType>[];
                };
                update: {
                    args: VerificationGatesPermissionUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>;
                };
                updateMany: {
                    args: VerificationGatesPermissionUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: VerificationGatesPermissionUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>[];
                };
                upsert: {
                    args: VerificationGatesPermissionUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$VerificationGatesPermissionPayload>;
                };
            };
            payload: $VerificationGatesPermissionPayload<ExtArgs>;
        };
        WelcomeImageData: {
            fields: WelcomeImageDataFieldRefs;
            operations: {
                aggregate: {
                    args: WelcomeImageDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateWelcomeImageData>;
                };
                count: {
                    args: WelcomeImageDataCountArgs<ExtArgs>;
                    result: Optional<WelcomeImageDataCountAggregateOutputType> | number;
                };
                create: {
                    args: WelcomeImageDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>;
                };
                createMany: {
                    args: WelcomeImageDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: WelcomeImageDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>[];
                };
                delete: {
                    args: WelcomeImageDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>;
                };
                deleteMany: {
                    args: WelcomeImageDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: WelcomeImageDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: WelcomeImageDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>;
                };
                findMany: {
                    args: WelcomeImageDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>[];
                };
                findUnique: {
                    args: WelcomeImageDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: WelcomeImageDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>;
                };
                groupBy: {
                    args: WelcomeImageDataGroupByArgs<ExtArgs>;
                    result: Optional<WelcomeImageDataGroupByOutputType>[];
                };
                update: {
                    args: WelcomeImageDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>;
                };
                updateMany: {
                    args: WelcomeImageDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: WelcomeImageDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>[];
                };
                upsert: {
                    args: WelcomeImageDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$WelcomeImageDataPayload>;
                };
            };
            payload: $WelcomeImageDataPayload<ExtArgs>;
        };
        XPDrops: {
            fields: XPDropsFieldRefs;
            operations: {
                aggregate: {
                    args: XPDropsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateXPDrops>;
                };
                count: {
                    args: XPDropsCountArgs<ExtArgs>;
                    result: Optional<XPDropsCountAggregateOutputType> | number;
                };
                create: {
                    args: XPDropsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>;
                };
                createMany: {
                    args: XPDropsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: XPDropsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>[];
                };
                delete: {
                    args: XPDropsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>;
                };
                deleteMany: {
                    args: XPDropsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: XPDropsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload> | null;
                };
                findFirstOrThrow: {
                    args: XPDropsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>;
                };
                findMany: {
                    args: XPDropsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>[];
                };
                findUnique: {
                    args: XPDropsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: XPDropsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>;
                };
                groupBy: {
                    args: XPDropsGroupByArgs<ExtArgs>;
                    result: Optional<XPDropsGroupByOutputType>[];
                };
                update: {
                    args: XPDropsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>;
                };
                updateMany: {
                    args: XPDropsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: XPDropsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>[];
                };
                upsert: {
                    args: XPDropsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$XPDropsPayload>;
                };
            };
            payload: $XPDropsPayload<ExtArgs>;
        };
        XPStreaks: {
            fields: XPStreaksFieldRefs;
            operations: {
                aggregate: {
                    args: XPStreaksAggregateArgs<ExtArgs>;
                    result: Optional<AggregateXPStreaks>;
                };
                count: {
                    args: XPStreaksCountArgs<ExtArgs>;
                    result: Optional<XPStreaksCountAggregateOutputType> | number;
                };
                create: {
                    args: XPStreaksCreateArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>;
                };
                createMany: {
                    args: XPStreaksCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: XPStreaksCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>[];
                };
                delete: {
                    args: XPStreaksDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>;
                };
                deleteMany: {
                    args: XPStreaksDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: XPStreaksFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload> | null;
                };
                findFirstOrThrow: {
                    args: XPStreaksFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>;
                };
                findMany: {
                    args: XPStreaksFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>[];
                };
                findUnique: {
                    args: XPStreaksFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload> | null;
                };
                findUniqueOrThrow: {
                    args: XPStreaksFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>;
                };
                groupBy: {
                    args: XPStreaksGroupByArgs<ExtArgs>;
                    result: Optional<XPStreaksGroupByOutputType>[];
                };
                update: {
                    args: XPStreaksUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>;
                };
                updateMany: {
                    args: XPStreaksUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: XPStreaksUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>[];
                };
                upsert: {
                    args: XPStreaksUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$XPStreaksPayload>;
                };
            };
            payload: $XPStreaksPayload<ExtArgs>;
        };
    };
} & {
    other: {
        operations: {
            $executeRaw: {
                args: [query: TemplateStringsArray | Sql, values: any[]];
                result: any;
            };
            $executeRawUnsafe: { args: [query: string, values: any[]]; result: any };
            $queryRaw: {
                args: [query: TemplateStringsArray | Sql, values: any[]];
                result: any;
            };
            $queryRawUnsafe: { args: [query: string, values: any[]]; result: any };
        };
        payload: any;
    };
}