Type Alias TypeMap<ExtArgs, GlobalOmitOptions>

TypeMap<ExtArgs, GlobalOmitOptions>: {
    globalOmitOptions: {
        omit: GlobalOmitOptions;
    };
    meta: {
        modelProps:
            | "client"
            | "clientFAQ"
            | "clientChangelog"
            | "clientBlog"
            | "clientLogRawData"
            | "drop"
            | "dropGame"
            | "guildDrops"
            | "guildDropsWebhook"
            | "guildDropsGame"
            | "guildDropsGameWebhook"
            | "sentDrop"
            | "guildGiveaway"
            | "guildGiveawayEntry"
            | "guildGiveawayFilter"
            | "guildGiveawayRoleBonus"
            | "guildGiveawayRequirements"
            | "guild"
            | "guildPremium"
            | "guildDisableBranding"
            | "guildRandomMessage"
            | "guildAutoLiveRole"
            | "guildAutoLiveRoleFilter"
            | "guildStatusRole"
            | "guildStatusRoleFilter"
            | "guildLinkedRole"
            | "guildNotificationOverride"
            | "guildCustomSingleMessage"
            | "guildSingleMessageWebhook"
            | "guildCustomMessage"
            | "guildMessageEmbed"
            | "guildEmbedField"
            | "guildMessageButton"
            | "guildMessageWebhook"
            | "guildStickyMessage"
            | "guildStickyMessageEmbed"
            | "guildStickyEmbedField"
            | "guildStickyMessageButton"
            | "guildStickyMessageWebhook"
            | "guildGettingStarted"
            | "kickStreamer"
            | "kSCustomMessage"
            | "kSMessageEmbed"
            | "kSEmbedField"
            | "kSMessageButton"
            | "kSMessageWebhook"
            | "kSRoleWithUsers"
            | "kSLeaderBoardSyncRole"
            | "kSLeaderBoardRole"
            | "kSGiftedSubRole"
            | "kSStatsChannelId"
            | "kSCurrentlyLive"
            | "member"
            | "r2Storage"
            | "r2StorageGuild"
            | "rumbleStreamer"
            | "rSCustomMessage"
            | "rSMessageEmbed"
            | "rSEmbedField"
            | "rSMessageButton"
            | "rSMessageWebhook"
            | "rSStatsChannelId"
            | "rSCurrentlyLive"
            | "guildStarboard"
            | "guildStarboardFilter"
            | "guildStarboardMessages"
            | "guildStarboardMessage"
            | "team"
            | "teamMember"
            | "activeInvite"
            | "tiktokStreamer"
            | "tTSCustomMessage"
            | "tTSMessageEmbed"
            | "tTSEmbedField"
            | "tTSMessageButton"
            | "tTSMessageWebhook"
            | "tTSStatsChannelId"
            | "tTSCurrentlyLive"
            | "twitchStreamer"
            | "tSCustomMessage"
            | "tSMessageEmbed"
            | "tSEmbedField"
            | "tSMessageButton"
            | "tSMessageWebhook"
            | "tSStatsChannelId"
            | "tSCurrentlyLive"
            | "user"
            | "userPremium"
            | "userMediaShare"
            | "userMediaShareSettings"
            | "userMediaSharePermissions"
            | "userSession"
            | "userLinkedRoles"
            | "userActiveGuildSubscription"
            | "userBirthday"
            | "userKickAccount"
            | "userKickAccountSubscribedTo"
            | "userTwitchAccount"
            | "userRumbleAccount"
            | "userGettingStarted"
            | "userNotifications"
            | "userNotificationData"
            | "youtubeStreamer"
            | "yTSCustomMessage"
            | "yTSMessageEmbed"
            | "yTSEmbedField"
            | "yTSMessageButton"
            | "yTSMessageWebhook"
            | "yTSStatsChannelId"
            | "yTSCurrentlyLive"
            | "allEnumsModel";
        txIsolationLevel: Prisma.TransactionIsolationLevel;
    };
    model: {
        ActiveInvite: {
            fields: ActiveInviteFieldRefs;
            operations: {
                aggregate: {
                    args: ActiveInviteAggregateArgs<ExtArgs>;
                    result: Optional<AggregateActiveInvite>;
                };
                count: {
                    args: ActiveInviteCountArgs<ExtArgs>;
                    result: Optional<ActiveInviteCountAggregateOutputType> | number;
                };
                create: {
                    args: ActiveInviteCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>;
                };
                createMany: {
                    args: ActiveInviteCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ActiveInviteCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>[];
                };
                delete: {
                    args: ActiveInviteDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>;
                };
                deleteMany: {
                    args: ActiveInviteDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ActiveInviteFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload> | null;
                };
                findFirstOrThrow: {
                    args: ActiveInviteFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>;
                };
                findMany: {
                    args: ActiveInviteFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>[];
                };
                findUnique: {
                    args: ActiveInviteFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload> | null;
                };
                findUniqueOrThrow: {
                    args: ActiveInviteFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>;
                };
                groupBy: {
                    args: ActiveInviteGroupByArgs<ExtArgs>;
                    result: Optional<ActiveInviteGroupByOutputType>[];
                };
                update: {
                    args: ActiveInviteUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>;
                };
                updateMany: {
                    args: ActiveInviteUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ActiveInviteUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>[];
                };
                upsert: {
                    args: ActiveInviteUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ActiveInvitePayload>;
                };
            };
            payload: $ActiveInvitePayload<ExtArgs>;
        };
        AllEnumsModel: {
            fields: AllEnumsModelFieldRefs;
            operations: {
                aggregate: {
                    args: AllEnumsModelAggregateArgs<ExtArgs>;
                    result: Optional<AggregateAllEnumsModel>;
                };
                count: {
                    args: AllEnumsModelCountArgs<ExtArgs>;
                    result: Optional<AllEnumsModelCountAggregateOutputType> | number;
                };
                create: {
                    args: AllEnumsModelCreateArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>;
                };
                createMany: {
                    args: AllEnumsModelCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: AllEnumsModelCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>[];
                };
                delete: {
                    args: AllEnumsModelDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>;
                };
                deleteMany: {
                    args: AllEnumsModelDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: AllEnumsModelFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload> | null;
                };
                findFirstOrThrow: {
                    args: AllEnumsModelFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>;
                };
                findMany: {
                    args: AllEnumsModelFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>[];
                };
                findUnique: {
                    args: AllEnumsModelFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload> | null;
                };
                findUniqueOrThrow: {
                    args: AllEnumsModelFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>;
                };
                groupBy: {
                    args: AllEnumsModelGroupByArgs<ExtArgs>;
                    result: Optional<AllEnumsModelGroupByOutputType>[];
                };
                update: {
                    args: AllEnumsModelUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>;
                };
                updateMany: {
                    args: AllEnumsModelUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: AllEnumsModelUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>[];
                };
                upsert: {
                    args: AllEnumsModelUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$AllEnumsModelPayload>;
                };
            };
            payload: $AllEnumsModelPayload<ExtArgs>;
        };
        Client: {
            fields: ClientFieldRefs;
            operations: {
                aggregate: {
                    args: ClientAggregateArgs<ExtArgs>;
                    result: Optional<AggregateClient>;
                };
                count: {
                    args: ClientCountArgs<ExtArgs>;
                    result: Optional<ClientCountAggregateOutputType> | number;
                };
                create: {
                    args: ClientCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>;
                };
                createMany: {
                    args: ClientCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ClientCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>[];
                };
                delete: {
                    args: ClientDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>;
                };
                deleteMany: {
                    args: ClientDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ClientFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload> | null;
                };
                findFirstOrThrow: {
                    args: ClientFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>;
                };
                findMany: {
                    args: ClientFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>[];
                };
                findUnique: {
                    args: ClientFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ClientFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>;
                };
                groupBy: {
                    args: ClientGroupByArgs<ExtArgs>;
                    result: Optional<ClientGroupByOutputType>[];
                };
                update: {
                    args: ClientUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>;
                };
                updateMany: {
                    args: ClientUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ClientUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>[];
                };
                upsert: {
                    args: ClientUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ClientPayload>;
                };
            };
            payload: $ClientPayload<ExtArgs>;
        };
        ClientBlog: {
            fields: ClientBlogFieldRefs;
            operations: {
                aggregate: {
                    args: ClientBlogAggregateArgs<ExtArgs>;
                    result: Optional<AggregateClientBlog>;
                };
                count: {
                    args: ClientBlogCountArgs<ExtArgs>;
                    result: Optional<ClientBlogCountAggregateOutputType> | number;
                };
                create: {
                    args: ClientBlogCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>;
                };
                createMany: {
                    args: ClientBlogCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ClientBlogCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>[];
                };
                delete: {
                    args: ClientBlogDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>;
                };
                deleteMany: {
                    args: ClientBlogDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ClientBlogFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload> | null;
                };
                findFirstOrThrow: {
                    args: ClientBlogFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>;
                };
                findMany: {
                    args: ClientBlogFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>[];
                };
                findUnique: {
                    args: ClientBlogFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ClientBlogFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>;
                };
                groupBy: {
                    args: ClientBlogGroupByArgs<ExtArgs>;
                    result: Optional<ClientBlogGroupByOutputType>[];
                };
                update: {
                    args: ClientBlogUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>;
                };
                updateMany: {
                    args: ClientBlogUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ClientBlogUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>[];
                };
                upsert: {
                    args: ClientBlogUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ClientBlogPayload>;
                };
            };
            payload: $ClientBlogPayload<ExtArgs>;
        };
        ClientChangelog: {
            fields: ClientChangelogFieldRefs;
            operations: {
                aggregate: {
                    args: ClientChangelogAggregateArgs<ExtArgs>;
                    result: Optional<AggregateClientChangelog>;
                };
                count: {
                    args: ClientChangelogCountArgs<ExtArgs>;
                    result: Optional<ClientChangelogCountAggregateOutputType> | number;
                };
                create: {
                    args: ClientChangelogCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>;
                };
                createMany: {
                    args: ClientChangelogCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ClientChangelogCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>[];
                };
                delete: {
                    args: ClientChangelogDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>;
                };
                deleteMany: {
                    args: ClientChangelogDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ClientChangelogFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload> | null;
                };
                findFirstOrThrow: {
                    args: ClientChangelogFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>;
                };
                findMany: {
                    args: ClientChangelogFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>[];
                };
                findUnique: {
                    args: ClientChangelogFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ClientChangelogFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>;
                };
                groupBy: {
                    args: ClientChangelogGroupByArgs<ExtArgs>;
                    result: Optional<ClientChangelogGroupByOutputType>[];
                };
                update: {
                    args: ClientChangelogUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>;
                };
                updateMany: {
                    args: ClientChangelogUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ClientChangelogUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>[];
                };
                upsert: {
                    args: ClientChangelogUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ClientChangelogPayload>;
                };
            };
            payload: $ClientChangelogPayload<ExtArgs>;
        };
        ClientFAQ: {
            fields: ClientFAQFieldRefs;
            operations: {
                aggregate: {
                    args: ClientFAQAggregateArgs<ExtArgs>;
                    result: Optional<AggregateClientFAQ>;
                };
                count: {
                    args: ClientFAQCountArgs<ExtArgs>;
                    result: Optional<ClientFAQCountAggregateOutputType> | number;
                };
                create: {
                    args: ClientFAQCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>;
                };
                createMany: {
                    args: ClientFAQCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ClientFAQCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>[];
                };
                delete: {
                    args: ClientFAQDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>;
                };
                deleteMany: {
                    args: ClientFAQDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ClientFAQFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload> | null;
                };
                findFirstOrThrow: {
                    args: ClientFAQFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>;
                };
                findMany: {
                    args: ClientFAQFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>[];
                };
                findUnique: {
                    args: ClientFAQFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ClientFAQFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>;
                };
                groupBy: {
                    args: ClientFAQGroupByArgs<ExtArgs>;
                    result: Optional<ClientFAQGroupByOutputType>[];
                };
                update: {
                    args: ClientFAQUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>;
                };
                updateMany: {
                    args: ClientFAQUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ClientFAQUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>[];
                };
                upsert: {
                    args: ClientFAQUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ClientFAQPayload>;
                };
            };
            payload: $ClientFAQPayload<ExtArgs>;
        };
        ClientLogRawData: {
            fields: ClientLogRawDataFieldRefs;
            operations: {
                aggregate: {
                    args: ClientLogRawDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateClientLogRawData>;
                };
                count: {
                    args: ClientLogRawDataCountArgs<ExtArgs>;
                    result: Optional<ClientLogRawDataCountAggregateOutputType> | number;
                };
                create: {
                    args: ClientLogRawDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>;
                };
                createMany: {
                    args: ClientLogRawDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: ClientLogRawDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>[];
                };
                delete: {
                    args: ClientLogRawDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>;
                };
                deleteMany: {
                    args: ClientLogRawDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: ClientLogRawDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: ClientLogRawDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>;
                };
                findMany: {
                    args: ClientLogRawDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>[];
                };
                findUnique: {
                    args: ClientLogRawDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: ClientLogRawDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>;
                };
                groupBy: {
                    args: ClientLogRawDataGroupByArgs<ExtArgs>;
                    result: Optional<ClientLogRawDataGroupByOutputType>[];
                };
                update: {
                    args: ClientLogRawDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>;
                };
                updateMany: {
                    args: ClientLogRawDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: ClientLogRawDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>[];
                };
                upsert: {
                    args: ClientLogRawDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$ClientLogRawDataPayload>;
                };
            };
            payload: $ClientLogRawDataPayload<ExtArgs>;
        };
        Drop: {
            fields: DropFieldRefs;
            operations: {
                aggregate: {
                    args: DropAggregateArgs<ExtArgs>;
                    result: Optional<AggregateDrop>;
                };
                count: {
                    args: DropCountArgs<ExtArgs>;
                    result: Optional<DropCountAggregateOutputType> | number;
                };
                create: {
                    args: DropCreateArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>;
                };
                createMany: {
                    args: DropCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: DropCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>[];
                };
                delete: {
                    args: DropDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>;
                };
                deleteMany: {
                    args: DropDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: DropFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload> | null;
                };
                findFirstOrThrow: {
                    args: DropFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>;
                };
                findMany: {
                    args: DropFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>[];
                };
                findUnique: {
                    args: DropFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload> | null;
                };
                findUniqueOrThrow: {
                    args: DropFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>;
                };
                groupBy: {
                    args: DropGroupByArgs<ExtArgs>;
                    result: Optional<DropGroupByOutputType>[];
                };
                update: {
                    args: DropUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>;
                };
                updateMany: {
                    args: DropUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: DropUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>[];
                };
                upsert: {
                    args: DropUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$DropPayload>;
                };
            };
            payload: $DropPayload<ExtArgs>;
        };
        DropGame: {
            fields: DropGameFieldRefs;
            operations: {
                aggregate: {
                    args: DropGameAggregateArgs<ExtArgs>;
                    result: Optional<AggregateDropGame>;
                };
                count: {
                    args: DropGameCountArgs<ExtArgs>;
                    result: Optional<DropGameCountAggregateOutputType> | number;
                };
                create: {
                    args: DropGameCreateArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>;
                };
                createMany: {
                    args: DropGameCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: DropGameCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>[];
                };
                delete: {
                    args: DropGameDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>;
                };
                deleteMany: {
                    args: DropGameDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: DropGameFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload> | null;
                };
                findFirstOrThrow: {
                    args: DropGameFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>;
                };
                findMany: {
                    args: DropGameFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>[];
                };
                findUnique: {
                    args: DropGameFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload> | null;
                };
                findUniqueOrThrow: {
                    args: DropGameFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>;
                };
                groupBy: {
                    args: DropGameGroupByArgs<ExtArgs>;
                    result: Optional<DropGameGroupByOutputType>[];
                };
                update: {
                    args: DropGameUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>;
                };
                updateMany: {
                    args: DropGameUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: DropGameUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>[];
                };
                upsert: {
                    args: DropGameUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$DropGamePayload>;
                };
            };
            payload: $DropGamePayload<ExtArgs>;
        };
        Guild: {
            fields: GuildFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuild>;
                };
                count: {
                    args: GuildCountArgs<ExtArgs>;
                    result: Optional<GuildCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>;
                };
                createMany: {
                    args: GuildCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>[];
                };
                delete: {
                    args: GuildDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>;
                };
                deleteMany: {
                    args: GuildDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>;
                };
                findMany: {
                    args: GuildFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>[];
                };
                findUnique: {
                    args: GuildFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>;
                };
                groupBy: {
                    args: GuildGroupByArgs<ExtArgs>;
                    result: Optional<GuildGroupByOutputType>[];
                };
                update: {
                    args: GuildUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>;
                };
                updateMany: {
                    args: GuildUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>[];
                };
                upsert: {
                    args: GuildUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPayload>;
                };
            };
            payload: $GuildPayload<ExtArgs>;
        };
        GuildAutoLiveRole: {
            fields: GuildAutoLiveRoleFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAutoLiveRoleAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildAutoLiveRole>;
                };
                count: {
                    args: GuildAutoLiveRoleCountArgs<ExtArgs>;
                    result: Optional<GuildAutoLiveRoleCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildAutoLiveRoleCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>;
                };
                createMany: {
                    args: GuildAutoLiveRoleCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildAutoLiveRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>[];
                };
                delete: {
                    args: GuildAutoLiveRoleDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>;
                };
                deleteMany: {
                    args: GuildAutoLiveRoleDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildAutoLiveRoleFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildAutoLiveRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>;
                };
                findMany: {
                    args: GuildAutoLiveRoleFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>[];
                };
                findUnique: {
                    args: GuildAutoLiveRoleFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildAutoLiveRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>;
                };
                groupBy: {
                    args: GuildAutoLiveRoleGroupByArgs<ExtArgs>;
                    result: Optional<GuildAutoLiveRoleGroupByOutputType>[];
                };
                update: {
                    args: GuildAutoLiveRoleUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>;
                };
                updateMany: {
                    args: GuildAutoLiveRoleUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildAutoLiveRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>[];
                };
                upsert: {
                    args: GuildAutoLiveRoleUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRolePayload>;
                };
            };
            payload: $GuildAutoLiveRolePayload<ExtArgs>;
        };
        GuildAutoLiveRoleFilter: {
            fields: GuildAutoLiveRoleFilterFieldRefs;
            operations: {
                aggregate: {
                    args: GuildAutoLiveRoleFilterAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildAutoLiveRoleFilter>;
                };
                count: {
                    args: GuildAutoLiveRoleFilterCountArgs<ExtArgs>;
                    result: Optional<GuildAutoLiveRoleFilterCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildAutoLiveRoleFilterCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>;
                };
                createMany: {
                    args: GuildAutoLiveRoleFilterCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildAutoLiveRoleFilterCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>[];
                };
                delete: {
                    args: GuildAutoLiveRoleFilterDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>;
                };
                deleteMany: {
                    args: GuildAutoLiveRoleFilterDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildAutoLiveRoleFilterFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildAutoLiveRoleFilterFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>;
                };
                findMany: {
                    args: GuildAutoLiveRoleFilterFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>[];
                };
                findUnique: {
                    args: GuildAutoLiveRoleFilterFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildAutoLiveRoleFilterFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>;
                };
                groupBy: {
                    args: GuildAutoLiveRoleFilterGroupByArgs<ExtArgs>;
                    result: Optional<GuildAutoLiveRoleFilterGroupByOutputType>[];
                };
                update: {
                    args: GuildAutoLiveRoleFilterUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>;
                };
                updateMany: {
                    args: GuildAutoLiveRoleFilterUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildAutoLiveRoleFilterUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>[];
                };
                upsert: {
                    args: GuildAutoLiveRoleFilterUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildAutoLiveRoleFilterPayload>;
                };
            };
            payload: $GuildAutoLiveRoleFilterPayload<ExtArgs>;
        };
        GuildCustomMessage: {
            fields: GuildCustomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: GuildCustomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildCustomMessage>;
                };
                count: {
                    args: GuildCustomMessageCountArgs<ExtArgs>;
                    result: Optional<GuildCustomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildCustomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>;
                };
                createMany: {
                    args: GuildCustomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildCustomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>[];
                };
                delete: {
                    args: GuildCustomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>;
                };
                deleteMany: {
                    args: GuildCustomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildCustomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildCustomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>;
                };
                findMany: {
                    args: GuildCustomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>[];
                };
                findUnique: {
                    args: GuildCustomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildCustomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>;
                };
                groupBy: {
                    args: GuildCustomMessageGroupByArgs<ExtArgs>;
                    result: Optional<GuildCustomMessageGroupByOutputType>[];
                };
                update: {
                    args: GuildCustomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>;
                };
                updateMany: {
                    args: GuildCustomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildCustomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>[];
                };
                upsert: {
                    args: GuildCustomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomMessagePayload>;
                };
            };
            payload: $GuildCustomMessagePayload<ExtArgs>;
        };
        GuildCustomSingleMessage: {
            fields: GuildCustomSingleMessageFieldRefs;
            operations: {
                aggregate: {
                    args: GuildCustomSingleMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildCustomSingleMessage>;
                };
                count: {
                    args: GuildCustomSingleMessageCountArgs<ExtArgs>;
                    result: Optional<GuildCustomSingleMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildCustomSingleMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>;
                };
                createMany: {
                    args: GuildCustomSingleMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildCustomSingleMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>[];
                };
                delete: {
                    args: GuildCustomSingleMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>;
                };
                deleteMany: {
                    args: GuildCustomSingleMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildCustomSingleMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildCustomSingleMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>;
                };
                findMany: {
                    args: GuildCustomSingleMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>[];
                };
                findUnique: {
                    args: GuildCustomSingleMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildCustomSingleMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>;
                };
                groupBy: {
                    args: GuildCustomSingleMessageGroupByArgs<ExtArgs>;
                    result: Optional<GuildCustomSingleMessageGroupByOutputType>[];
                };
                update: {
                    args: GuildCustomSingleMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>;
                };
                updateMany: {
                    args: GuildCustomSingleMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildCustomSingleMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>[];
                };
                upsert: {
                    args: GuildCustomSingleMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildCustomSingleMessagePayload>;
                };
            };
            payload: $GuildCustomSingleMessagePayload<ExtArgs>;
        };
        GuildDisableBranding: {
            fields: GuildDisableBrandingFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDisableBrandingAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDisableBranding>;
                };
                count: {
                    args: GuildDisableBrandingCountArgs<ExtArgs>;
                    result: Optional<GuildDisableBrandingCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildDisableBrandingCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>;
                };
                createMany: {
                    args: GuildDisableBrandingCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDisableBrandingCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>[];
                };
                delete: {
                    args: GuildDisableBrandingDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>;
                };
                deleteMany: {
                    args: GuildDisableBrandingDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDisableBrandingFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDisableBrandingFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>;
                };
                findMany: {
                    args: GuildDisableBrandingFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>[];
                };
                findUnique: {
                    args: GuildDisableBrandingFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDisableBrandingFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>;
                };
                groupBy: {
                    args: GuildDisableBrandingGroupByArgs<ExtArgs>;
                    result: Optional<GuildDisableBrandingGroupByOutputType>[];
                };
                update: {
                    args: GuildDisableBrandingUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>;
                };
                updateMany: {
                    args: GuildDisableBrandingUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDisableBrandingUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>[];
                };
                upsert: {
                    args: GuildDisableBrandingUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDisableBrandingPayload>;
                };
            };
            payload: $GuildDisableBrandingPayload<ExtArgs>;
        };
        GuildDrops: {
            fields: GuildDropsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDropsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDrops>;
                };
                count: {
                    args: GuildDropsCountArgs<ExtArgs>;
                    result: Optional<GuildDropsCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildDropsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>;
                };
                createMany: {
                    args: GuildDropsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDropsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>[];
                };
                delete: {
                    args: GuildDropsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>;
                };
                deleteMany: {
                    args: GuildDropsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDropsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDropsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>;
                };
                findMany: {
                    args: GuildDropsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>[];
                };
                findUnique: {
                    args: GuildDropsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDropsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>;
                };
                groupBy: {
                    args: GuildDropsGroupByArgs<ExtArgs>;
                    result: Optional<GuildDropsGroupByOutputType>[];
                };
                update: {
                    args: GuildDropsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>;
                };
                updateMany: {
                    args: GuildDropsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDropsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>[];
                };
                upsert: {
                    args: GuildDropsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsPayload>;
                };
            };
            payload: $GuildDropsPayload<ExtArgs>;
        };
        GuildDropsGame: {
            fields: GuildDropsGameFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDropsGameAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDropsGame>;
                };
                count: {
                    args: GuildDropsGameCountArgs<ExtArgs>;
                    result: Optional<GuildDropsGameCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildDropsGameCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>;
                };
                createMany: {
                    args: GuildDropsGameCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDropsGameCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>[];
                };
                delete: {
                    args: GuildDropsGameDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>;
                };
                deleteMany: {
                    args: GuildDropsGameDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDropsGameFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDropsGameFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>;
                };
                findMany: {
                    args: GuildDropsGameFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>[];
                };
                findUnique: {
                    args: GuildDropsGameFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDropsGameFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>;
                };
                groupBy: {
                    args: GuildDropsGameGroupByArgs<ExtArgs>;
                    result: Optional<GuildDropsGameGroupByOutputType>[];
                };
                update: {
                    args: GuildDropsGameUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>;
                };
                updateMany: {
                    args: GuildDropsGameUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDropsGameUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>[];
                };
                upsert: {
                    args: GuildDropsGameUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGamePayload>;
                };
            };
            payload: $GuildDropsGamePayload<ExtArgs>;
        };
        GuildDropsGameWebhook: {
            fields: GuildDropsGameWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDropsGameWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDropsGameWebhook>;
                };
                count: {
                    args: GuildDropsGameWebhookCountArgs<ExtArgs>;
                    result: Optional<GuildDropsGameWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildDropsGameWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>;
                };
                createMany: {
                    args: GuildDropsGameWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDropsGameWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>[];
                };
                delete: {
                    args: GuildDropsGameWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>;
                };
                deleteMany: {
                    args: GuildDropsGameWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDropsGameWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDropsGameWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>;
                };
                findMany: {
                    args: GuildDropsGameWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>[];
                };
                findUnique: {
                    args: GuildDropsGameWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDropsGameWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>;
                };
                groupBy: {
                    args: GuildDropsGameWebhookGroupByArgs<ExtArgs>;
                    result: Optional<GuildDropsGameWebhookGroupByOutputType>[];
                };
                update: {
                    args: GuildDropsGameWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>;
                };
                updateMany: {
                    args: GuildDropsGameWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDropsGameWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>[];
                };
                upsert: {
                    args: GuildDropsGameWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsGameWebhookPayload>;
                };
            };
            payload: $GuildDropsGameWebhookPayload<ExtArgs>;
        };
        GuildDropsWebhook: {
            fields: GuildDropsWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: GuildDropsWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildDropsWebhook>;
                };
                count: {
                    args: GuildDropsWebhookCountArgs<ExtArgs>;
                    result: Optional<GuildDropsWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildDropsWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>;
                };
                createMany: {
                    args: GuildDropsWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildDropsWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>[];
                };
                delete: {
                    args: GuildDropsWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>;
                };
                deleteMany: {
                    args: GuildDropsWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildDropsWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildDropsWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>;
                };
                findMany: {
                    args: GuildDropsWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>[];
                };
                findUnique: {
                    args: GuildDropsWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildDropsWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>;
                };
                groupBy: {
                    args: GuildDropsWebhookGroupByArgs<ExtArgs>;
                    result: Optional<GuildDropsWebhookGroupByOutputType>[];
                };
                update: {
                    args: GuildDropsWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>;
                };
                updateMany: {
                    args: GuildDropsWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildDropsWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>[];
                };
                upsert: {
                    args: GuildDropsWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildDropsWebhookPayload>;
                };
            };
            payload: $GuildDropsWebhookPayload<ExtArgs>;
        };
        GuildEmbedField: {
            fields: GuildEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: GuildEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildEmbedField>;
                };
                count: {
                    args: GuildEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<GuildEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>;
                };
                createMany: {
                    args: GuildEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>[];
                };
                delete: {
                    args: GuildEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>;
                };
                deleteMany: {
                    args: GuildEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>;
                };
                findMany: {
                    args: GuildEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>[];
                };
                findUnique: {
                    args: GuildEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>;
                };
                groupBy: {
                    args: GuildEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<GuildEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: GuildEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>;
                };
                updateMany: {
                    args: GuildEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>[];
                };
                upsert: {
                    args: GuildEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildEmbedFieldPayload>;
                };
            };
            payload: $GuildEmbedFieldPayload<ExtArgs>;
        };
        GuildGettingStarted: {
            fields: GuildGettingStartedFieldRefs;
            operations: {
                aggregate: {
                    args: GuildGettingStartedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildGettingStarted>;
                };
                count: {
                    args: GuildGettingStartedCountArgs<ExtArgs>;
                    result: Optional<GuildGettingStartedCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildGettingStartedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>;
                };
                createMany: {
                    args: GuildGettingStartedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildGettingStartedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>[];
                };
                delete: {
                    args: GuildGettingStartedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>;
                };
                deleteMany: {
                    args: GuildGettingStartedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildGettingStartedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildGettingStartedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>;
                };
                findMany: {
                    args: GuildGettingStartedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>[];
                };
                findUnique: {
                    args: GuildGettingStartedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildGettingStartedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>;
                };
                groupBy: {
                    args: GuildGettingStartedGroupByArgs<ExtArgs>;
                    result: Optional<GuildGettingStartedGroupByOutputType>[];
                };
                update: {
                    args: GuildGettingStartedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>;
                };
                updateMany: {
                    args: GuildGettingStartedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildGettingStartedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>[];
                };
                upsert: {
                    args: GuildGettingStartedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGettingStartedPayload>;
                };
            };
            payload: $GuildGettingStartedPayload<ExtArgs>;
        };
        GuildGiveaway: {
            fields: GuildGiveawayFieldRefs;
            operations: {
                aggregate: {
                    args: GuildGiveawayAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildGiveaway>;
                };
                count: {
                    args: GuildGiveawayCountArgs<ExtArgs>;
                    result: Optional<GuildGiveawayCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildGiveawayCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>;
                };
                createMany: {
                    args: GuildGiveawayCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildGiveawayCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>[];
                };
                delete: {
                    args: GuildGiveawayDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>;
                };
                deleteMany: {
                    args: GuildGiveawayDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildGiveawayFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildGiveawayFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>;
                };
                findMany: {
                    args: GuildGiveawayFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>[];
                };
                findUnique: {
                    args: GuildGiveawayFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildGiveawayFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>;
                };
                groupBy: {
                    args: GuildGiveawayGroupByArgs<ExtArgs>;
                    result: Optional<GuildGiveawayGroupByOutputType>[];
                };
                update: {
                    args: GuildGiveawayUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>;
                };
                updateMany: {
                    args: GuildGiveawayUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildGiveawayUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>[];
                };
                upsert: {
                    args: GuildGiveawayUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayPayload>;
                };
            };
            payload: $GuildGiveawayPayload<ExtArgs>;
        };
        GuildGiveawayEntry: {
            fields: GuildGiveawayEntryFieldRefs;
            operations: {
                aggregate: {
                    args: GuildGiveawayEntryAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildGiveawayEntry>;
                };
                count: {
                    args: GuildGiveawayEntryCountArgs<ExtArgs>;
                    result: Optional<GuildGiveawayEntryCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildGiveawayEntryCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>;
                };
                createMany: {
                    args: GuildGiveawayEntryCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildGiveawayEntryCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>[];
                };
                delete: {
                    args: GuildGiveawayEntryDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>;
                };
                deleteMany: {
                    args: GuildGiveawayEntryDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildGiveawayEntryFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildGiveawayEntryFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>;
                };
                findMany: {
                    args: GuildGiveawayEntryFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>[];
                };
                findUnique: {
                    args: GuildGiveawayEntryFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildGiveawayEntryFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>;
                };
                groupBy: {
                    args: GuildGiveawayEntryGroupByArgs<ExtArgs>;
                    result: Optional<GuildGiveawayEntryGroupByOutputType>[];
                };
                update: {
                    args: GuildGiveawayEntryUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>;
                };
                updateMany: {
                    args: GuildGiveawayEntryUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildGiveawayEntryUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>[];
                };
                upsert: {
                    args: GuildGiveawayEntryUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayEntryPayload>;
                };
            };
            payload: $GuildGiveawayEntryPayload<ExtArgs>;
        };
        GuildGiveawayFilter: {
            fields: GuildGiveawayFilterFieldRefs;
            operations: {
                aggregate: {
                    args: GuildGiveawayFilterAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildGiveawayFilter>;
                };
                count: {
                    args: GuildGiveawayFilterCountArgs<ExtArgs>;
                    result: Optional<GuildGiveawayFilterCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildGiveawayFilterCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>;
                };
                createMany: {
                    args: GuildGiveawayFilterCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildGiveawayFilterCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>[];
                };
                delete: {
                    args: GuildGiveawayFilterDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>;
                };
                deleteMany: {
                    args: GuildGiveawayFilterDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildGiveawayFilterFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildGiveawayFilterFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>;
                };
                findMany: {
                    args: GuildGiveawayFilterFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>[];
                };
                findUnique: {
                    args: GuildGiveawayFilterFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildGiveawayFilterFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>;
                };
                groupBy: {
                    args: GuildGiveawayFilterGroupByArgs<ExtArgs>;
                    result: Optional<GuildGiveawayFilterGroupByOutputType>[];
                };
                update: {
                    args: GuildGiveawayFilterUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>;
                };
                updateMany: {
                    args: GuildGiveawayFilterUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildGiveawayFilterUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>[];
                };
                upsert: {
                    args: GuildGiveawayFilterUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayFilterPayload>;
                };
            };
            payload: $GuildGiveawayFilterPayload<ExtArgs>;
        };
        GuildGiveawayRequirements: {
            fields: GuildGiveawayRequirementsFieldRefs;
            operations: {
                aggregate: {
                    args: GuildGiveawayRequirementsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildGiveawayRequirements>;
                };
                count: {
                    args: GuildGiveawayRequirementsCountArgs<ExtArgs>;
                    result: Optional<GuildGiveawayRequirementsCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildGiveawayRequirementsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>;
                };
                createMany: {
                    args: GuildGiveawayRequirementsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildGiveawayRequirementsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>[];
                };
                delete: {
                    args: GuildGiveawayRequirementsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>;
                };
                deleteMany: {
                    args: GuildGiveawayRequirementsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildGiveawayRequirementsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildGiveawayRequirementsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>;
                };
                findMany: {
                    args: GuildGiveawayRequirementsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>[];
                };
                findUnique: {
                    args: GuildGiveawayRequirementsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildGiveawayRequirementsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>;
                };
                groupBy: {
                    args: GuildGiveawayRequirementsGroupByArgs<ExtArgs>;
                    result: Optional<GuildGiveawayRequirementsGroupByOutputType>[];
                };
                update: {
                    args: GuildGiveawayRequirementsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>;
                };
                updateMany: {
                    args: GuildGiveawayRequirementsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildGiveawayRequirementsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>[];
                };
                upsert: {
                    args: GuildGiveawayRequirementsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRequirementsPayload>;
                };
            };
            payload: $GuildGiveawayRequirementsPayload<ExtArgs>;
        };
        GuildGiveawayRoleBonus: {
            fields: GuildGiveawayRoleBonusFieldRefs;
            operations: {
                aggregate: {
                    args: GuildGiveawayRoleBonusAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildGiveawayRoleBonus>;
                };
                count: {
                    args: GuildGiveawayRoleBonusCountArgs<ExtArgs>;
                    result: Optional<GuildGiveawayRoleBonusCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildGiveawayRoleBonusCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>;
                };
                createMany: {
                    args: GuildGiveawayRoleBonusCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildGiveawayRoleBonusCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>[];
                };
                delete: {
                    args: GuildGiveawayRoleBonusDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>;
                };
                deleteMany: {
                    args: GuildGiveawayRoleBonusDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildGiveawayRoleBonusFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildGiveawayRoleBonusFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>;
                };
                findMany: {
                    args: GuildGiveawayRoleBonusFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>[];
                };
                findUnique: {
                    args: GuildGiveawayRoleBonusFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildGiveawayRoleBonusFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>;
                };
                groupBy: {
                    args: GuildGiveawayRoleBonusGroupByArgs<ExtArgs>;
                    result: Optional<GuildGiveawayRoleBonusGroupByOutputType>[];
                };
                update: {
                    args: GuildGiveawayRoleBonusUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>;
                };
                updateMany: {
                    args: GuildGiveawayRoleBonusUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildGiveawayRoleBonusUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>[];
                };
                upsert: {
                    args: GuildGiveawayRoleBonusUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildGiveawayRoleBonusPayload>;
                };
            };
            payload: $GuildGiveawayRoleBonusPayload<ExtArgs>;
        };
        GuildLinkedRole: {
            fields: GuildLinkedRoleFieldRefs;
            operations: {
                aggregate: {
                    args: GuildLinkedRoleAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildLinkedRole>;
                };
                count: {
                    args: GuildLinkedRoleCountArgs<ExtArgs>;
                    result: Optional<GuildLinkedRoleCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildLinkedRoleCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>;
                };
                createMany: {
                    args: GuildLinkedRoleCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildLinkedRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>[];
                };
                delete: {
                    args: GuildLinkedRoleDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>;
                };
                deleteMany: {
                    args: GuildLinkedRoleDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildLinkedRoleFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildLinkedRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>;
                };
                findMany: {
                    args: GuildLinkedRoleFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>[];
                };
                findUnique: {
                    args: GuildLinkedRoleFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildLinkedRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>;
                };
                groupBy: {
                    args: GuildLinkedRoleGroupByArgs<ExtArgs>;
                    result: Optional<GuildLinkedRoleGroupByOutputType>[];
                };
                update: {
                    args: GuildLinkedRoleUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>;
                };
                updateMany: {
                    args: GuildLinkedRoleUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildLinkedRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>[];
                };
                upsert: {
                    args: GuildLinkedRoleUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildLinkedRolePayload>;
                };
            };
            payload: $GuildLinkedRolePayload<ExtArgs>;
        };
        GuildMessageButton: {
            fields: GuildMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: GuildMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildMessageButton>;
                };
                count: {
                    args: GuildMessageButtonCountArgs<ExtArgs>;
                    result: Optional<GuildMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>;
                };
                createMany: {
                    args: GuildMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>[];
                };
                delete: {
                    args: GuildMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>;
                };
                deleteMany: {
                    args: GuildMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>;
                };
                findMany: {
                    args: GuildMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>[];
                };
                findUnique: {
                    args: GuildMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>;
                };
                groupBy: {
                    args: GuildMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<GuildMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: GuildMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>;
                };
                updateMany: {
                    args: GuildMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>[];
                };
                upsert: {
                    args: GuildMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageButtonPayload>;
                };
            };
            payload: $GuildMessageButtonPayload<ExtArgs>;
        };
        GuildMessageEmbed: {
            fields: GuildMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: GuildMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildMessageEmbed>;
                };
                count: {
                    args: GuildMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<GuildMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>;
                };
                createMany: {
                    args: GuildMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>[];
                };
                delete: {
                    args: GuildMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>;
                };
                deleteMany: {
                    args: GuildMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>;
                };
                findMany: {
                    args: GuildMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>[];
                };
                findUnique: {
                    args: GuildMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>;
                };
                groupBy: {
                    args: GuildMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<GuildMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: GuildMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>;
                };
                updateMany: {
                    args: GuildMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>[];
                };
                upsert: {
                    args: GuildMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageEmbedPayload>;
                };
            };
            payload: $GuildMessageEmbedPayload<ExtArgs>;
        };
        GuildMessageWebhook: {
            fields: GuildMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: GuildMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildMessageWebhook>;
                };
                count: {
                    args: GuildMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<GuildMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>;
                };
                createMany: {
                    args: GuildMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>[];
                };
                delete: {
                    args: GuildMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>;
                };
                deleteMany: {
                    args: GuildMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>;
                };
                findMany: {
                    args: GuildMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>[];
                };
                findUnique: {
                    args: GuildMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>;
                };
                groupBy: {
                    args: GuildMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<GuildMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: GuildMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>;
                };
                updateMany: {
                    args: GuildMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>[];
                };
                upsert: {
                    args: GuildMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildMessageWebhookPayload>;
                };
            };
            payload: $GuildMessageWebhookPayload<ExtArgs>;
        };
        GuildNotificationOverride: {
            fields: GuildNotificationOverrideFieldRefs;
            operations: {
                aggregate: {
                    args: GuildNotificationOverrideAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildNotificationOverride>;
                };
                count: {
                    args: GuildNotificationOverrideCountArgs<ExtArgs>;
                    result: Optional<GuildNotificationOverrideCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildNotificationOverrideCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>;
                };
                createMany: {
                    args: GuildNotificationOverrideCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildNotificationOverrideCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>[];
                };
                delete: {
                    args: GuildNotificationOverrideDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>;
                };
                deleteMany: {
                    args: GuildNotificationOverrideDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildNotificationOverrideFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildNotificationOverrideFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>;
                };
                findMany: {
                    args: GuildNotificationOverrideFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>[];
                };
                findUnique: {
                    args: GuildNotificationOverrideFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildNotificationOverrideFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>;
                };
                groupBy: {
                    args: GuildNotificationOverrideGroupByArgs<ExtArgs>;
                    result: Optional<GuildNotificationOverrideGroupByOutputType>[];
                };
                update: {
                    args: GuildNotificationOverrideUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>;
                };
                updateMany: {
                    args: GuildNotificationOverrideUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildNotificationOverrideUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>[];
                };
                upsert: {
                    args: GuildNotificationOverrideUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildNotificationOverridePayload>;
                };
            };
            payload: $GuildNotificationOverridePayload<ExtArgs>;
        };
        GuildPremium: {
            fields: GuildPremiumFieldRefs;
            operations: {
                aggregate: {
                    args: GuildPremiumAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildPremium>;
                };
                count: {
                    args: GuildPremiumCountArgs<ExtArgs>;
                    result: Optional<GuildPremiumCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildPremiumCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>;
                };
                createMany: {
                    args: GuildPremiumCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildPremiumCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>[];
                };
                delete: {
                    args: GuildPremiumDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>;
                };
                deleteMany: {
                    args: GuildPremiumDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildPremiumFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildPremiumFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>;
                };
                findMany: {
                    args: GuildPremiumFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>[];
                };
                findUnique: {
                    args: GuildPremiumFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildPremiumFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>;
                };
                groupBy: {
                    args: GuildPremiumGroupByArgs<ExtArgs>;
                    result: Optional<GuildPremiumGroupByOutputType>[];
                };
                update: {
                    args: GuildPremiumUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>;
                };
                updateMany: {
                    args: GuildPremiumUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildPremiumUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>[];
                };
                upsert: {
                    args: GuildPremiumUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildPremiumPayload>;
                };
            };
            payload: $GuildPremiumPayload<ExtArgs>;
        };
        GuildRandomMessage: {
            fields: GuildRandomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: GuildRandomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildRandomMessage>;
                };
                count: {
                    args: GuildRandomMessageCountArgs<ExtArgs>;
                    result: Optional<GuildRandomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildRandomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>;
                };
                createMany: {
                    args: GuildRandomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildRandomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>[];
                };
                delete: {
                    args: GuildRandomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>;
                };
                deleteMany: {
                    args: GuildRandomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildRandomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildRandomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>;
                };
                findMany: {
                    args: GuildRandomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>[];
                };
                findUnique: {
                    args: GuildRandomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildRandomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>;
                };
                groupBy: {
                    args: GuildRandomMessageGroupByArgs<ExtArgs>;
                    result: Optional<GuildRandomMessageGroupByOutputType>[];
                };
                update: {
                    args: GuildRandomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>;
                };
                updateMany: {
                    args: GuildRandomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildRandomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>[];
                };
                upsert: {
                    args: GuildRandomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildRandomMessagePayload>;
                };
            };
            payload: $GuildRandomMessagePayload<ExtArgs>;
        };
        GuildSingleMessageWebhook: {
            fields: GuildSingleMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: GuildSingleMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildSingleMessageWebhook>;
                };
                count: {
                    args: GuildSingleMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<GuildSingleMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildSingleMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>;
                };
                createMany: {
                    args: GuildSingleMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildSingleMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>[];
                };
                delete: {
                    args: GuildSingleMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>;
                };
                deleteMany: {
                    args: GuildSingleMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildSingleMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildSingleMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>;
                };
                findMany: {
                    args: GuildSingleMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>[];
                };
                findUnique: {
                    args: GuildSingleMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildSingleMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>;
                };
                groupBy: {
                    args: GuildSingleMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<GuildSingleMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: GuildSingleMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>;
                };
                updateMany: {
                    args: GuildSingleMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildSingleMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>[];
                };
                upsert: {
                    args: GuildSingleMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildSingleMessageWebhookPayload>;
                };
            };
            payload: $GuildSingleMessageWebhookPayload<ExtArgs>;
        };
        GuildStarboard: {
            fields: GuildStarboardFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStarboardAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStarboard>;
                };
                count: {
                    args: GuildStarboardCountArgs<ExtArgs>;
                    result: Optional<GuildStarboardCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStarboardCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>;
                };
                createMany: {
                    args: GuildStarboardCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStarboardCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>[];
                };
                delete: {
                    args: GuildStarboardDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>;
                };
                deleteMany: {
                    args: GuildStarboardDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStarboardFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStarboardFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>;
                };
                findMany: {
                    args: GuildStarboardFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>[];
                };
                findUnique: {
                    args: GuildStarboardFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStarboardFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>;
                };
                groupBy: {
                    args: GuildStarboardGroupByArgs<ExtArgs>;
                    result: Optional<GuildStarboardGroupByOutputType>[];
                };
                update: {
                    args: GuildStarboardUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>;
                };
                updateMany: {
                    args: GuildStarboardUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStarboardUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>[];
                };
                upsert: {
                    args: GuildStarboardUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardPayload>;
                };
            };
            payload: $GuildStarboardPayload<ExtArgs>;
        };
        GuildStarboardFilter: {
            fields: GuildStarboardFilterFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStarboardFilterAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStarboardFilter>;
                };
                count: {
                    args: GuildStarboardFilterCountArgs<ExtArgs>;
                    result: Optional<GuildStarboardFilterCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStarboardFilterCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>;
                };
                createMany: {
                    args: GuildStarboardFilterCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStarboardFilterCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>[];
                };
                delete: {
                    args: GuildStarboardFilterDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>;
                };
                deleteMany: {
                    args: GuildStarboardFilterDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStarboardFilterFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStarboardFilterFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>;
                };
                findMany: {
                    args: GuildStarboardFilterFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>[];
                };
                findUnique: {
                    args: GuildStarboardFilterFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStarboardFilterFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>;
                };
                groupBy: {
                    args: GuildStarboardFilterGroupByArgs<ExtArgs>;
                    result: Optional<GuildStarboardFilterGroupByOutputType>[];
                };
                update: {
                    args: GuildStarboardFilterUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>;
                };
                updateMany: {
                    args: GuildStarboardFilterUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStarboardFilterUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>[];
                };
                upsert: {
                    args: GuildStarboardFilterUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardFilterPayload>;
                };
            };
            payload: $GuildStarboardFilterPayload<ExtArgs>;
        };
        GuildStarboardMessage: {
            fields: GuildStarboardMessageFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStarboardMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStarboardMessage>;
                };
                count: {
                    args: GuildStarboardMessageCountArgs<ExtArgs>;
                    result: Optional<GuildStarboardMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStarboardMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>;
                };
                createMany: {
                    args: GuildStarboardMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStarboardMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>[];
                };
                delete: {
                    args: GuildStarboardMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>;
                };
                deleteMany: {
                    args: GuildStarboardMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStarboardMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStarboardMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>;
                };
                findMany: {
                    args: GuildStarboardMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>[];
                };
                findUnique: {
                    args: GuildStarboardMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStarboardMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>;
                };
                groupBy: {
                    args: GuildStarboardMessageGroupByArgs<ExtArgs>;
                    result: Optional<GuildStarboardMessageGroupByOutputType>[];
                };
                update: {
                    args: GuildStarboardMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>;
                };
                updateMany: {
                    args: GuildStarboardMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStarboardMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>[];
                };
                upsert: {
                    args: GuildStarboardMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagePayload>;
                };
            };
            payload: $GuildStarboardMessagePayload<ExtArgs>;
        };
        GuildStarboardMessages: {
            fields: GuildStarboardMessagesFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStarboardMessagesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStarboardMessages>;
                };
                count: {
                    args: GuildStarboardMessagesCountArgs<ExtArgs>;
                    result: Optional<GuildStarboardMessagesCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStarboardMessagesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>;
                };
                createMany: {
                    args: GuildStarboardMessagesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStarboardMessagesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>[];
                };
                delete: {
                    args: GuildStarboardMessagesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>;
                };
                deleteMany: {
                    args: GuildStarboardMessagesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStarboardMessagesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStarboardMessagesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>;
                };
                findMany: {
                    args: GuildStarboardMessagesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>[];
                };
                findUnique: {
                    args: GuildStarboardMessagesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStarboardMessagesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>;
                };
                groupBy: {
                    args: GuildStarboardMessagesGroupByArgs<ExtArgs>;
                    result: Optional<GuildStarboardMessagesGroupByOutputType>[];
                };
                update: {
                    args: GuildStarboardMessagesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>;
                };
                updateMany: {
                    args: GuildStarboardMessagesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStarboardMessagesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>[];
                };
                upsert: {
                    args: GuildStarboardMessagesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStarboardMessagesPayload>;
                };
            };
            payload: $GuildStarboardMessagesPayload<ExtArgs>;
        };
        GuildStatusRole: {
            fields: GuildStatusRoleFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStatusRoleAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStatusRole>;
                };
                count: {
                    args: GuildStatusRoleCountArgs<ExtArgs>;
                    result: Optional<GuildStatusRoleCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStatusRoleCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>;
                };
                createMany: {
                    args: GuildStatusRoleCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStatusRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>[];
                };
                delete: {
                    args: GuildStatusRoleDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>;
                };
                deleteMany: {
                    args: GuildStatusRoleDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStatusRoleFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStatusRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>;
                };
                findMany: {
                    args: GuildStatusRoleFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>[];
                };
                findUnique: {
                    args: GuildStatusRoleFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStatusRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>;
                };
                groupBy: {
                    args: GuildStatusRoleGroupByArgs<ExtArgs>;
                    result: Optional<GuildStatusRoleGroupByOutputType>[];
                };
                update: {
                    args: GuildStatusRoleUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>;
                };
                updateMany: {
                    args: GuildStatusRoleUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStatusRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>[];
                };
                upsert: {
                    args: GuildStatusRoleUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRolePayload>;
                };
            };
            payload: $GuildStatusRolePayload<ExtArgs>;
        };
        GuildStatusRoleFilter: {
            fields: GuildStatusRoleFilterFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStatusRoleFilterAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStatusRoleFilter>;
                };
                count: {
                    args: GuildStatusRoleFilterCountArgs<ExtArgs>;
                    result: Optional<GuildStatusRoleFilterCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStatusRoleFilterCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>;
                };
                createMany: {
                    args: GuildStatusRoleFilterCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStatusRoleFilterCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>[];
                };
                delete: {
                    args: GuildStatusRoleFilterDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>;
                };
                deleteMany: {
                    args: GuildStatusRoleFilterDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStatusRoleFilterFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStatusRoleFilterFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>;
                };
                findMany: {
                    args: GuildStatusRoleFilterFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>[];
                };
                findUnique: {
                    args: GuildStatusRoleFilterFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStatusRoleFilterFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>;
                };
                groupBy: {
                    args: GuildStatusRoleFilterGroupByArgs<ExtArgs>;
                    result: Optional<GuildStatusRoleFilterGroupByOutputType>[];
                };
                update: {
                    args: GuildStatusRoleFilterUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>;
                };
                updateMany: {
                    args: GuildStatusRoleFilterUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStatusRoleFilterUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>[];
                };
                upsert: {
                    args: GuildStatusRoleFilterUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStatusRoleFilterPayload>;
                };
            };
            payload: $GuildStatusRoleFilterPayload<ExtArgs>;
        };
        GuildStickyEmbedField: {
            fields: GuildStickyEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStickyEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStickyEmbedField>;
                };
                count: {
                    args: GuildStickyEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<GuildStickyEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStickyEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>;
                };
                createMany: {
                    args: GuildStickyEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStickyEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>[];
                };
                delete: {
                    args: GuildStickyEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>;
                };
                deleteMany: {
                    args: GuildStickyEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStickyEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStickyEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>;
                };
                findMany: {
                    args: GuildStickyEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>[];
                };
                findUnique: {
                    args: GuildStickyEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStickyEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>;
                };
                groupBy: {
                    args: GuildStickyEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<GuildStickyEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: GuildStickyEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>;
                };
                updateMany: {
                    args: GuildStickyEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStickyEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>[];
                };
                upsert: {
                    args: GuildStickyEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyEmbedFieldPayload>;
                };
            };
            payload: $GuildStickyEmbedFieldPayload<ExtArgs>;
        };
        GuildStickyMessage: {
            fields: GuildStickyMessageFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStickyMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStickyMessage>;
                };
                count: {
                    args: GuildStickyMessageCountArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStickyMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>;
                };
                createMany: {
                    args: GuildStickyMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStickyMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>[];
                };
                delete: {
                    args: GuildStickyMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>;
                };
                deleteMany: {
                    args: GuildStickyMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStickyMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStickyMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>;
                };
                findMany: {
                    args: GuildStickyMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>[];
                };
                findUnique: {
                    args: GuildStickyMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStickyMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>;
                };
                groupBy: {
                    args: GuildStickyMessageGroupByArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageGroupByOutputType>[];
                };
                update: {
                    args: GuildStickyMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>;
                };
                updateMany: {
                    args: GuildStickyMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStickyMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>[];
                };
                upsert: {
                    args: GuildStickyMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessagePayload>;
                };
            };
            payload: $GuildStickyMessagePayload<ExtArgs>;
        };
        GuildStickyMessageButton: {
            fields: GuildStickyMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStickyMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStickyMessageButton>;
                };
                count: {
                    args: GuildStickyMessageButtonCountArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStickyMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>;
                };
                createMany: {
                    args: GuildStickyMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStickyMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>[];
                };
                delete: {
                    args: GuildStickyMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>;
                };
                deleteMany: {
                    args: GuildStickyMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStickyMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStickyMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>;
                };
                findMany: {
                    args: GuildStickyMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>[];
                };
                findUnique: {
                    args: GuildStickyMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStickyMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>;
                };
                groupBy: {
                    args: GuildStickyMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: GuildStickyMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>;
                };
                updateMany: {
                    args: GuildStickyMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStickyMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>[];
                };
                upsert: {
                    args: GuildStickyMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageButtonPayload>;
                };
            };
            payload: $GuildStickyMessageButtonPayload<ExtArgs>;
        };
        GuildStickyMessageEmbed: {
            fields: GuildStickyMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStickyMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStickyMessageEmbed>;
                };
                count: {
                    args: GuildStickyMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStickyMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>;
                };
                createMany: {
                    args: GuildStickyMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStickyMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>[];
                };
                delete: {
                    args: GuildStickyMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>;
                };
                deleteMany: {
                    args: GuildStickyMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStickyMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStickyMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>;
                };
                findMany: {
                    args: GuildStickyMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>[];
                };
                findUnique: {
                    args: GuildStickyMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStickyMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>;
                };
                groupBy: {
                    args: GuildStickyMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: GuildStickyMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>;
                };
                updateMany: {
                    args: GuildStickyMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStickyMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>[];
                };
                upsert: {
                    args: GuildStickyMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageEmbedPayload>;
                };
            };
            payload: $GuildStickyMessageEmbedPayload<ExtArgs>;
        };
        GuildStickyMessageWebhook: {
            fields: GuildStickyMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: GuildStickyMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateGuildStickyMessageWebhook>;
                };
                count: {
                    args: GuildStickyMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: GuildStickyMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>;
                };
                createMany: {
                    args: GuildStickyMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: GuildStickyMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>[];
                };
                delete: {
                    args: GuildStickyMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>;
                };
                deleteMany: {
                    args: GuildStickyMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: GuildStickyMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: GuildStickyMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>;
                };
                findMany: {
                    args: GuildStickyMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>[];
                };
                findUnique: {
                    args: GuildStickyMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: GuildStickyMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>;
                };
                groupBy: {
                    args: GuildStickyMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<GuildStickyMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: GuildStickyMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>;
                };
                updateMany: {
                    args: GuildStickyMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: GuildStickyMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>[];
                };
                upsert: {
                    args: GuildStickyMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$GuildStickyMessageWebhookPayload>;
                };
            };
            payload: $GuildStickyMessageWebhookPayload<ExtArgs>;
        };
        KSCurrentlyLive: {
            fields: KSCurrentlyLiveFieldRefs;
            operations: {
                aggregate: {
                    args: KSCurrentlyLiveAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSCurrentlyLive>;
                };
                count: {
                    args: KSCurrentlyLiveCountArgs<ExtArgs>;
                    result: Optional<KSCurrentlyLiveCountAggregateOutputType> | number;
                };
                create: {
                    args: KSCurrentlyLiveCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>;
                };
                createMany: {
                    args: KSCurrentlyLiveCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSCurrentlyLiveCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>[];
                };
                delete: {
                    args: KSCurrentlyLiveDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>;
                };
                deleteMany: {
                    args: KSCurrentlyLiveDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSCurrentlyLiveFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload> | null;
                };
                findFirstOrThrow: {
                    args: KSCurrentlyLiveFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>;
                };
                findMany: {
                    args: KSCurrentlyLiveFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>[];
                };
                findUnique: {
                    args: KSCurrentlyLiveFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSCurrentlyLiveFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>;
                };
                groupBy: {
                    args: KSCurrentlyLiveGroupByArgs<ExtArgs>;
                    result: Optional<KSCurrentlyLiveGroupByOutputType>[];
                };
                update: {
                    args: KSCurrentlyLiveUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>;
                };
                updateMany: {
                    args: KSCurrentlyLiveUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSCurrentlyLiveUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>[];
                };
                upsert: {
                    args: KSCurrentlyLiveUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSCurrentlyLivePayload>;
                };
            };
            payload: $KSCurrentlyLivePayload<ExtArgs>;
        };
        KSCustomMessage: {
            fields: KSCustomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: KSCustomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSCustomMessage>;
                };
                count: {
                    args: KSCustomMessageCountArgs<ExtArgs>;
                    result: Optional<KSCustomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: KSCustomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>;
                };
                createMany: {
                    args: KSCustomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSCustomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>[];
                };
                delete: {
                    args: KSCustomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>;
                };
                deleteMany: {
                    args: KSCustomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSCustomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: KSCustomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>;
                };
                findMany: {
                    args: KSCustomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>[];
                };
                findUnique: {
                    args: KSCustomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSCustomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>;
                };
                groupBy: {
                    args: KSCustomMessageGroupByArgs<ExtArgs>;
                    result: Optional<KSCustomMessageGroupByOutputType>[];
                };
                update: {
                    args: KSCustomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>;
                };
                updateMany: {
                    args: KSCustomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSCustomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>[];
                };
                upsert: {
                    args: KSCustomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSCustomMessagePayload>;
                };
            };
            payload: $KSCustomMessagePayload<ExtArgs>;
        };
        KSEmbedField: {
            fields: KSEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: KSEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSEmbedField>;
                };
                count: {
                    args: KSEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<KSEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: KSEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>;
                };
                createMany: {
                    args: KSEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>[];
                };
                delete: {
                    args: KSEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>;
                };
                deleteMany: {
                    args: KSEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: KSEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>;
                };
                findMany: {
                    args: KSEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>[];
                };
                findUnique: {
                    args: KSEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>;
                };
                groupBy: {
                    args: KSEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<KSEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: KSEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>;
                };
                updateMany: {
                    args: KSEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>[];
                };
                upsert: {
                    args: KSEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSEmbedFieldPayload>;
                };
            };
            payload: $KSEmbedFieldPayload<ExtArgs>;
        };
        KSGiftedSubRole: {
            fields: KSGiftedSubRoleFieldRefs;
            operations: {
                aggregate: {
                    args: KSGiftedSubRoleAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSGiftedSubRole>;
                };
                count: {
                    args: KSGiftedSubRoleCountArgs<ExtArgs>;
                    result: Optional<KSGiftedSubRoleCountAggregateOutputType> | number;
                };
                create: {
                    args: KSGiftedSubRoleCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>;
                };
                createMany: {
                    args: KSGiftedSubRoleCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSGiftedSubRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>[];
                };
                delete: {
                    args: KSGiftedSubRoleDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>;
                };
                deleteMany: {
                    args: KSGiftedSubRoleDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSGiftedSubRoleFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: KSGiftedSubRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>;
                };
                findMany: {
                    args: KSGiftedSubRoleFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>[];
                };
                findUnique: {
                    args: KSGiftedSubRoleFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSGiftedSubRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>;
                };
                groupBy: {
                    args: KSGiftedSubRoleGroupByArgs<ExtArgs>;
                    result: Optional<KSGiftedSubRoleGroupByOutputType>[];
                };
                update: {
                    args: KSGiftedSubRoleUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>;
                };
                updateMany: {
                    args: KSGiftedSubRoleUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSGiftedSubRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>[];
                };
                upsert: {
                    args: KSGiftedSubRoleUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSGiftedSubRolePayload>;
                };
            };
            payload: $KSGiftedSubRolePayload<ExtArgs>;
        };
        KSLeaderBoardRole: {
            fields: KSLeaderBoardRoleFieldRefs;
            operations: {
                aggregate: {
                    args: KSLeaderBoardRoleAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSLeaderBoardRole>;
                };
                count: {
                    args: KSLeaderBoardRoleCountArgs<ExtArgs>;
                    result: Optional<KSLeaderBoardRoleCountAggregateOutputType> | number;
                };
                create: {
                    args: KSLeaderBoardRoleCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>;
                };
                createMany: {
                    args: KSLeaderBoardRoleCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSLeaderBoardRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>[];
                };
                delete: {
                    args: KSLeaderBoardRoleDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>;
                };
                deleteMany: {
                    args: KSLeaderBoardRoleDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSLeaderBoardRoleFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: KSLeaderBoardRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>;
                };
                findMany: {
                    args: KSLeaderBoardRoleFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>[];
                };
                findUnique: {
                    args: KSLeaderBoardRoleFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSLeaderBoardRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>;
                };
                groupBy: {
                    args: KSLeaderBoardRoleGroupByArgs<ExtArgs>;
                    result: Optional<KSLeaderBoardRoleGroupByOutputType>[];
                };
                update: {
                    args: KSLeaderBoardRoleUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>;
                };
                updateMany: {
                    args: KSLeaderBoardRoleUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSLeaderBoardRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>[];
                };
                upsert: {
                    args: KSLeaderBoardRoleUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardRolePayload>;
                };
            };
            payload: $KSLeaderBoardRolePayload<ExtArgs>;
        };
        KSLeaderBoardSyncRole: {
            fields: KSLeaderBoardSyncRoleFieldRefs;
            operations: {
                aggregate: {
                    args: KSLeaderBoardSyncRoleAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSLeaderBoardSyncRole>;
                };
                count: {
                    args: KSLeaderBoardSyncRoleCountArgs<ExtArgs>;
                    result: Optional<KSLeaderBoardSyncRoleCountAggregateOutputType> | number;
                };
                create: {
                    args: KSLeaderBoardSyncRoleCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>;
                };
                createMany: {
                    args: KSLeaderBoardSyncRoleCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSLeaderBoardSyncRoleCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>[];
                };
                delete: {
                    args: KSLeaderBoardSyncRoleDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>;
                };
                deleteMany: {
                    args: KSLeaderBoardSyncRoleDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSLeaderBoardSyncRoleFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload> | null;
                };
                findFirstOrThrow: {
                    args: KSLeaderBoardSyncRoleFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>;
                };
                findMany: {
                    args: KSLeaderBoardSyncRoleFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>[];
                };
                findUnique: {
                    args: KSLeaderBoardSyncRoleFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSLeaderBoardSyncRoleFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>;
                };
                groupBy: {
                    args: KSLeaderBoardSyncRoleGroupByArgs<ExtArgs>;
                    result: Optional<KSLeaderBoardSyncRoleGroupByOutputType>[];
                };
                update: {
                    args: KSLeaderBoardSyncRoleUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>;
                };
                updateMany: {
                    args: KSLeaderBoardSyncRoleUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSLeaderBoardSyncRoleUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>[];
                };
                upsert: {
                    args: KSLeaderBoardSyncRoleUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSLeaderBoardSyncRolePayload>;
                };
            };
            payload: $KSLeaderBoardSyncRolePayload<ExtArgs>;
        };
        KSMessageButton: {
            fields: KSMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: KSMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSMessageButton>;
                };
                count: {
                    args: KSMessageButtonCountArgs<ExtArgs>;
                    result: Optional<KSMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: KSMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>;
                };
                createMany: {
                    args: KSMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>[];
                };
                delete: {
                    args: KSMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>;
                };
                deleteMany: {
                    args: KSMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: KSMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>;
                };
                findMany: {
                    args: KSMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>[];
                };
                findUnique: {
                    args: KSMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>;
                };
                groupBy: {
                    args: KSMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<KSMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: KSMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>;
                };
                updateMany: {
                    args: KSMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>[];
                };
                upsert: {
                    args: KSMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageButtonPayload>;
                };
            };
            payload: $KSMessageButtonPayload<ExtArgs>;
        };
        KSMessageEmbed: {
            fields: KSMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: KSMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSMessageEmbed>;
                };
                count: {
                    args: KSMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<KSMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: KSMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>;
                };
                createMany: {
                    args: KSMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>[];
                };
                delete: {
                    args: KSMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>;
                };
                deleteMany: {
                    args: KSMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: KSMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>;
                };
                findMany: {
                    args: KSMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>[];
                };
                findUnique: {
                    args: KSMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>;
                };
                groupBy: {
                    args: KSMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<KSMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: KSMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>;
                };
                updateMany: {
                    args: KSMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>[];
                };
                upsert: {
                    args: KSMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageEmbedPayload>;
                };
            };
            payload: $KSMessageEmbedPayload<ExtArgs>;
        };
        KSMessageWebhook: {
            fields: KSMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: KSMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSMessageWebhook>;
                };
                count: {
                    args: KSMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<KSMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: KSMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>;
                };
                createMany: {
                    args: KSMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>[];
                };
                delete: {
                    args: KSMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>;
                };
                deleteMany: {
                    args: KSMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: KSMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>;
                };
                findMany: {
                    args: KSMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>[];
                };
                findUnique: {
                    args: KSMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>;
                };
                groupBy: {
                    args: KSMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<KSMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: KSMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>;
                };
                updateMany: {
                    args: KSMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>[];
                };
                upsert: {
                    args: KSMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSMessageWebhookPayload>;
                };
            };
            payload: $KSMessageWebhookPayload<ExtArgs>;
        };
        KSRoleWithUsers: {
            fields: KSRoleWithUsersFieldRefs;
            operations: {
                aggregate: {
                    args: KSRoleWithUsersAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSRoleWithUsers>;
                };
                count: {
                    args: KSRoleWithUsersCountArgs<ExtArgs>;
                    result: Optional<KSRoleWithUsersCountAggregateOutputType> | number;
                };
                create: {
                    args: KSRoleWithUsersCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>;
                };
                createMany: {
                    args: KSRoleWithUsersCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSRoleWithUsersCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>[];
                };
                delete: {
                    args: KSRoleWithUsersDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>;
                };
                deleteMany: {
                    args: KSRoleWithUsersDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSRoleWithUsersFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload> | null;
                };
                findFirstOrThrow: {
                    args: KSRoleWithUsersFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>;
                };
                findMany: {
                    args: KSRoleWithUsersFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>[];
                };
                findUnique: {
                    args: KSRoleWithUsersFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSRoleWithUsersFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>;
                };
                groupBy: {
                    args: KSRoleWithUsersGroupByArgs<ExtArgs>;
                    result: Optional<KSRoleWithUsersGroupByOutputType>[];
                };
                update: {
                    args: KSRoleWithUsersUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>;
                };
                updateMany: {
                    args: KSRoleWithUsersUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSRoleWithUsersUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>[];
                };
                upsert: {
                    args: KSRoleWithUsersUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSRoleWithUsersPayload>;
                };
            };
            payload: $KSRoleWithUsersPayload<ExtArgs>;
        };
        KSStatsChannelId: {
            fields: KSStatsChannelIdFieldRefs;
            operations: {
                aggregate: {
                    args: KSStatsChannelIdAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKSStatsChannelId>;
                };
                count: {
                    args: KSStatsChannelIdCountArgs<ExtArgs>;
                    result: Optional<KSStatsChannelIdCountAggregateOutputType> | number;
                };
                create: {
                    args: KSStatsChannelIdCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>;
                };
                createMany: {
                    args: KSStatsChannelIdCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KSStatsChannelIdCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>[];
                };
                delete: {
                    args: KSStatsChannelIdDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>;
                };
                deleteMany: {
                    args: KSStatsChannelIdDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KSStatsChannelIdFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload> | null;
                };
                findFirstOrThrow: {
                    args: KSStatsChannelIdFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>;
                };
                findMany: {
                    args: KSStatsChannelIdFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>[];
                };
                findUnique: {
                    args: KSStatsChannelIdFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KSStatsChannelIdFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>;
                };
                groupBy: {
                    args: KSStatsChannelIdGroupByArgs<ExtArgs>;
                    result: Optional<KSStatsChannelIdGroupByOutputType>[];
                };
                update: {
                    args: KSStatsChannelIdUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>;
                };
                updateMany: {
                    args: KSStatsChannelIdUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KSStatsChannelIdUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>[];
                };
                upsert: {
                    args: KSStatsChannelIdUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KSStatsChannelIdPayload>;
                };
            };
            payload: $KSStatsChannelIdPayload<ExtArgs>;
        };
        KickStreamer: {
            fields: KickStreamerFieldRefs;
            operations: {
                aggregate: {
                    args: KickStreamerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateKickStreamer>;
                };
                count: {
                    args: KickStreamerCountArgs<ExtArgs>;
                    result: Optional<KickStreamerCountAggregateOutputType> | number;
                };
                create: {
                    args: KickStreamerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>;
                };
                createMany: {
                    args: KickStreamerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: KickStreamerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>[];
                };
                delete: {
                    args: KickStreamerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>;
                };
                deleteMany: {
                    args: KickStreamerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: KickStreamerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload> | null;
                };
                findFirstOrThrow: {
                    args: KickStreamerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>;
                };
                findMany: {
                    args: KickStreamerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>[];
                };
                findUnique: {
                    args: KickStreamerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: KickStreamerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>;
                };
                groupBy: {
                    args: KickStreamerGroupByArgs<ExtArgs>;
                    result: Optional<KickStreamerGroupByOutputType>[];
                };
                update: {
                    args: KickStreamerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>;
                };
                updateMany: {
                    args: KickStreamerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: KickStreamerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>[];
                };
                upsert: {
                    args: KickStreamerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$KickStreamerPayload>;
                };
            };
            payload: $KickStreamerPayload<ExtArgs>;
        };
        Member: {
            fields: MemberFieldRefs;
            operations: {
                aggregate: {
                    args: MemberAggregateArgs<ExtArgs>;
                    result: Optional<AggregateMember>;
                };
                count: {
                    args: MemberCountArgs<ExtArgs>;
                    result: Optional<MemberCountAggregateOutputType> | number;
                };
                create: {
                    args: MemberCreateArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>;
                };
                createMany: {
                    args: MemberCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: MemberCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>[];
                };
                delete: {
                    args: MemberDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>;
                };
                deleteMany: {
                    args: MemberDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: MemberFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload> | null;
                };
                findFirstOrThrow: {
                    args: MemberFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>;
                };
                findMany: {
                    args: MemberFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>[];
                };
                findUnique: {
                    args: MemberFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload> | null;
                };
                findUniqueOrThrow: {
                    args: MemberFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>;
                };
                groupBy: {
                    args: MemberGroupByArgs<ExtArgs>;
                    result: Optional<MemberGroupByOutputType>[];
                };
                update: {
                    args: MemberUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>;
                };
                updateMany: {
                    args: MemberUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: MemberUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>[];
                };
                upsert: {
                    args: MemberUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$MemberPayload>;
                };
            };
            payload: $MemberPayload<ExtArgs>;
        };
        R2Storage: {
            fields: R2StorageFieldRefs;
            operations: {
                aggregate: {
                    args: R2StorageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateR2Storage>;
                };
                count: {
                    args: R2StorageCountArgs<ExtArgs>;
                    result: Optional<R2StorageCountAggregateOutputType> | number;
                };
                create: {
                    args: R2StorageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>;
                };
                createMany: {
                    args: R2StorageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: R2StorageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>[];
                };
                delete: {
                    args: R2StorageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>;
                };
                deleteMany: {
                    args: R2StorageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: R2StorageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload> | null;
                };
                findFirstOrThrow: {
                    args: R2StorageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>;
                };
                findMany: {
                    args: R2StorageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>[];
                };
                findUnique: {
                    args: R2StorageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload> | null;
                };
                findUniqueOrThrow: {
                    args: R2StorageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>;
                };
                groupBy: {
                    args: R2StorageGroupByArgs<ExtArgs>;
                    result: Optional<R2StorageGroupByOutputType>[];
                };
                update: {
                    args: R2StorageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>;
                };
                updateMany: {
                    args: R2StorageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: R2StorageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>[];
                };
                upsert: {
                    args: R2StorageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$R2StoragePayload>;
                };
            };
            payload: $R2StoragePayload<ExtArgs>;
        };
        R2StorageGuild: {
            fields: R2StorageGuildFieldRefs;
            operations: {
                aggregate: {
                    args: R2StorageGuildAggregateArgs<ExtArgs>;
                    result: Optional<AggregateR2StorageGuild>;
                };
                count: {
                    args: R2StorageGuildCountArgs<ExtArgs>;
                    result: Optional<R2StorageGuildCountAggregateOutputType> | number;
                };
                create: {
                    args: R2StorageGuildCreateArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>;
                };
                createMany: {
                    args: R2StorageGuildCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: R2StorageGuildCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>[];
                };
                delete: {
                    args: R2StorageGuildDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>;
                };
                deleteMany: {
                    args: R2StorageGuildDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: R2StorageGuildFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload> | null;
                };
                findFirstOrThrow: {
                    args: R2StorageGuildFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>;
                };
                findMany: {
                    args: R2StorageGuildFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>[];
                };
                findUnique: {
                    args: R2StorageGuildFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload> | null;
                };
                findUniqueOrThrow: {
                    args: R2StorageGuildFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>;
                };
                groupBy: {
                    args: R2StorageGuildGroupByArgs<ExtArgs>;
                    result: Optional<R2StorageGuildGroupByOutputType>[];
                };
                update: {
                    args: R2StorageGuildUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>;
                };
                updateMany: {
                    args: R2StorageGuildUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: R2StorageGuildUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>[];
                };
                upsert: {
                    args: R2StorageGuildUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$R2StorageGuildPayload>;
                };
            };
            payload: $R2StorageGuildPayload<ExtArgs>;
        };
        RSCurrentlyLive: {
            fields: RSCurrentlyLiveFieldRefs;
            operations: {
                aggregate: {
                    args: RSCurrentlyLiveAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSCurrentlyLive>;
                };
                count: {
                    args: RSCurrentlyLiveCountArgs<ExtArgs>;
                    result: Optional<RSCurrentlyLiveCountAggregateOutputType> | number;
                };
                create: {
                    args: RSCurrentlyLiveCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>;
                };
                createMany: {
                    args: RSCurrentlyLiveCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSCurrentlyLiveCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>[];
                };
                delete: {
                    args: RSCurrentlyLiveDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>;
                };
                deleteMany: {
                    args: RSCurrentlyLiveDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSCurrentlyLiveFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload> | null;
                };
                findFirstOrThrow: {
                    args: RSCurrentlyLiveFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>;
                };
                findMany: {
                    args: RSCurrentlyLiveFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>[];
                };
                findUnique: {
                    args: RSCurrentlyLiveFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSCurrentlyLiveFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>;
                };
                groupBy: {
                    args: RSCurrentlyLiveGroupByArgs<ExtArgs>;
                    result: Optional<RSCurrentlyLiveGroupByOutputType>[];
                };
                update: {
                    args: RSCurrentlyLiveUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>;
                };
                updateMany: {
                    args: RSCurrentlyLiveUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSCurrentlyLiveUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>[];
                };
                upsert: {
                    args: RSCurrentlyLiveUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSCurrentlyLivePayload>;
                };
            };
            payload: $RSCurrentlyLivePayload<ExtArgs>;
        };
        RSCustomMessage: {
            fields: RSCustomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: RSCustomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSCustomMessage>;
                };
                count: {
                    args: RSCustomMessageCountArgs<ExtArgs>;
                    result: Optional<RSCustomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: RSCustomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>;
                };
                createMany: {
                    args: RSCustomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSCustomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>[];
                };
                delete: {
                    args: RSCustomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>;
                };
                deleteMany: {
                    args: RSCustomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSCustomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: RSCustomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>;
                };
                findMany: {
                    args: RSCustomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>[];
                };
                findUnique: {
                    args: RSCustomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSCustomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>;
                };
                groupBy: {
                    args: RSCustomMessageGroupByArgs<ExtArgs>;
                    result: Optional<RSCustomMessageGroupByOutputType>[];
                };
                update: {
                    args: RSCustomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>;
                };
                updateMany: {
                    args: RSCustomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSCustomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>[];
                };
                upsert: {
                    args: RSCustomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSCustomMessagePayload>;
                };
            };
            payload: $RSCustomMessagePayload<ExtArgs>;
        };
        RSEmbedField: {
            fields: RSEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: RSEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSEmbedField>;
                };
                count: {
                    args: RSEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<RSEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: RSEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>;
                };
                createMany: {
                    args: RSEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>[];
                };
                delete: {
                    args: RSEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>;
                };
                deleteMany: {
                    args: RSEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: RSEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>;
                };
                findMany: {
                    args: RSEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>[];
                };
                findUnique: {
                    args: RSEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>;
                };
                groupBy: {
                    args: RSEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<RSEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: RSEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>;
                };
                updateMany: {
                    args: RSEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>[];
                };
                upsert: {
                    args: RSEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSEmbedFieldPayload>;
                };
            };
            payload: $RSEmbedFieldPayload<ExtArgs>;
        };
        RSMessageButton: {
            fields: RSMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: RSMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSMessageButton>;
                };
                count: {
                    args: RSMessageButtonCountArgs<ExtArgs>;
                    result: Optional<RSMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: RSMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>;
                };
                createMany: {
                    args: RSMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>[];
                };
                delete: {
                    args: RSMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>;
                };
                deleteMany: {
                    args: RSMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: RSMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>;
                };
                findMany: {
                    args: RSMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>[];
                };
                findUnique: {
                    args: RSMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>;
                };
                groupBy: {
                    args: RSMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<RSMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: RSMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>;
                };
                updateMany: {
                    args: RSMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>[];
                };
                upsert: {
                    args: RSMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageButtonPayload>;
                };
            };
            payload: $RSMessageButtonPayload<ExtArgs>;
        };
        RSMessageEmbed: {
            fields: RSMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: RSMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSMessageEmbed>;
                };
                count: {
                    args: RSMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<RSMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: RSMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>;
                };
                createMany: {
                    args: RSMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>[];
                };
                delete: {
                    args: RSMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>;
                };
                deleteMany: {
                    args: RSMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: RSMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>;
                };
                findMany: {
                    args: RSMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>[];
                };
                findUnique: {
                    args: RSMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>;
                };
                groupBy: {
                    args: RSMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<RSMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: RSMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>;
                };
                updateMany: {
                    args: RSMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>[];
                };
                upsert: {
                    args: RSMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageEmbedPayload>;
                };
            };
            payload: $RSMessageEmbedPayload<ExtArgs>;
        };
        RSMessageWebhook: {
            fields: RSMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: RSMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSMessageWebhook>;
                };
                count: {
                    args: RSMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<RSMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: RSMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>;
                };
                createMany: {
                    args: RSMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>[];
                };
                delete: {
                    args: RSMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>;
                };
                deleteMany: {
                    args: RSMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: RSMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>;
                };
                findMany: {
                    args: RSMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>[];
                };
                findUnique: {
                    args: RSMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>;
                };
                groupBy: {
                    args: RSMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<RSMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: RSMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>;
                };
                updateMany: {
                    args: RSMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>[];
                };
                upsert: {
                    args: RSMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSMessageWebhookPayload>;
                };
            };
            payload: $RSMessageWebhookPayload<ExtArgs>;
        };
        RSStatsChannelId: {
            fields: RSStatsChannelIdFieldRefs;
            operations: {
                aggregate: {
                    args: RSStatsChannelIdAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRSStatsChannelId>;
                };
                count: {
                    args: RSStatsChannelIdCountArgs<ExtArgs>;
                    result: Optional<RSStatsChannelIdCountAggregateOutputType> | number;
                };
                create: {
                    args: RSStatsChannelIdCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>;
                };
                createMany: {
                    args: RSStatsChannelIdCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RSStatsChannelIdCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>[];
                };
                delete: {
                    args: RSStatsChannelIdDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>;
                };
                deleteMany: {
                    args: RSStatsChannelIdDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RSStatsChannelIdFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload> | null;
                };
                findFirstOrThrow: {
                    args: RSStatsChannelIdFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>;
                };
                findMany: {
                    args: RSStatsChannelIdFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>[];
                };
                findUnique: {
                    args: RSStatsChannelIdFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload> | null;
                };
                findUniqueOrThrow: {
                    args: RSStatsChannelIdFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>;
                };
                groupBy: {
                    args: RSStatsChannelIdGroupByArgs<ExtArgs>;
                    result: Optional<RSStatsChannelIdGroupByOutputType>[];
                };
                update: {
                    args: RSStatsChannelIdUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>;
                };
                updateMany: {
                    args: RSStatsChannelIdUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RSStatsChannelIdUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>[];
                };
                upsert: {
                    args: RSStatsChannelIdUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RSStatsChannelIdPayload>;
                };
            };
            payload: $RSStatsChannelIdPayload<ExtArgs>;
        };
        RumbleStreamer: {
            fields: RumbleStreamerFieldRefs;
            operations: {
                aggregate: {
                    args: RumbleStreamerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateRumbleStreamer>;
                };
                count: {
                    args: RumbleStreamerCountArgs<ExtArgs>;
                    result: Optional<RumbleStreamerCountAggregateOutputType> | number;
                };
                create: {
                    args: RumbleStreamerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>;
                };
                createMany: {
                    args: RumbleStreamerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: RumbleStreamerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>[];
                };
                delete: {
                    args: RumbleStreamerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>;
                };
                deleteMany: {
                    args: RumbleStreamerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: RumbleStreamerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload> | null;
                };
                findFirstOrThrow: {
                    args: RumbleStreamerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>;
                };
                findMany: {
                    args: RumbleStreamerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>[];
                };
                findUnique: {
                    args: RumbleStreamerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: RumbleStreamerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>;
                };
                groupBy: {
                    args: RumbleStreamerGroupByArgs<ExtArgs>;
                    result: Optional<RumbleStreamerGroupByOutputType>[];
                };
                update: {
                    args: RumbleStreamerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>;
                };
                updateMany: {
                    args: RumbleStreamerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: RumbleStreamerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>[];
                };
                upsert: {
                    args: RumbleStreamerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$RumbleStreamerPayload>;
                };
            };
            payload: $RumbleStreamerPayload<ExtArgs>;
        };
        SentDrop: {
            fields: SentDropFieldRefs;
            operations: {
                aggregate: {
                    args: SentDropAggregateArgs<ExtArgs>;
                    result: Optional<AggregateSentDrop>;
                };
                count: {
                    args: SentDropCountArgs<ExtArgs>;
                    result: Optional<SentDropCountAggregateOutputType> | number;
                };
                create: {
                    args: SentDropCreateArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>;
                };
                createMany: {
                    args: SentDropCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: SentDropCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>[];
                };
                delete: {
                    args: SentDropDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>;
                };
                deleteMany: {
                    args: SentDropDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: SentDropFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload> | null;
                };
                findFirstOrThrow: {
                    args: SentDropFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>;
                };
                findMany: {
                    args: SentDropFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>[];
                };
                findUnique: {
                    args: SentDropFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload> | null;
                };
                findUniqueOrThrow: {
                    args: SentDropFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>;
                };
                groupBy: {
                    args: SentDropGroupByArgs<ExtArgs>;
                    result: Optional<SentDropGroupByOutputType>[];
                };
                update: {
                    args: SentDropUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>;
                };
                updateMany: {
                    args: SentDropUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: SentDropUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>[];
                };
                upsert: {
                    args: SentDropUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$SentDropPayload>;
                };
            };
            payload: $SentDropPayload<ExtArgs>;
        };
        TSCurrentlyLive: {
            fields: TSCurrentlyLiveFieldRefs;
            operations: {
                aggregate: {
                    args: TSCurrentlyLiveAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSCurrentlyLive>;
                };
                count: {
                    args: TSCurrentlyLiveCountArgs<ExtArgs>;
                    result: Optional<TSCurrentlyLiveCountAggregateOutputType> | number;
                };
                create: {
                    args: TSCurrentlyLiveCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>;
                };
                createMany: {
                    args: TSCurrentlyLiveCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSCurrentlyLiveCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>[];
                };
                delete: {
                    args: TSCurrentlyLiveDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>;
                };
                deleteMany: {
                    args: TSCurrentlyLiveDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSCurrentlyLiveFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload> | null;
                };
                findFirstOrThrow: {
                    args: TSCurrentlyLiveFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>;
                };
                findMany: {
                    args: TSCurrentlyLiveFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>[];
                };
                findUnique: {
                    args: TSCurrentlyLiveFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSCurrentlyLiveFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>;
                };
                groupBy: {
                    args: TSCurrentlyLiveGroupByArgs<ExtArgs>;
                    result: Optional<TSCurrentlyLiveGroupByOutputType>[];
                };
                update: {
                    args: TSCurrentlyLiveUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>;
                };
                updateMany: {
                    args: TSCurrentlyLiveUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSCurrentlyLiveUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>[];
                };
                upsert: {
                    args: TSCurrentlyLiveUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSCurrentlyLivePayload>;
                };
            };
            payload: $TSCurrentlyLivePayload<ExtArgs>;
        };
        TSCustomMessage: {
            fields: TSCustomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: TSCustomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSCustomMessage>;
                };
                count: {
                    args: TSCustomMessageCountArgs<ExtArgs>;
                    result: Optional<TSCustomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: TSCustomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>;
                };
                createMany: {
                    args: TSCustomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSCustomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>[];
                };
                delete: {
                    args: TSCustomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>;
                };
                deleteMany: {
                    args: TSCustomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSCustomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: TSCustomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>;
                };
                findMany: {
                    args: TSCustomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>[];
                };
                findUnique: {
                    args: TSCustomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSCustomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>;
                };
                groupBy: {
                    args: TSCustomMessageGroupByArgs<ExtArgs>;
                    result: Optional<TSCustomMessageGroupByOutputType>[];
                };
                update: {
                    args: TSCustomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>;
                };
                updateMany: {
                    args: TSCustomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSCustomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>[];
                };
                upsert: {
                    args: TSCustomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSCustomMessagePayload>;
                };
            };
            payload: $TSCustomMessagePayload<ExtArgs>;
        };
        TSEmbedField: {
            fields: TSEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: TSEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSEmbedField>;
                };
                count: {
                    args: TSEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<TSEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: TSEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>;
                };
                createMany: {
                    args: TSEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>[];
                };
                delete: {
                    args: TSEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>;
                };
                deleteMany: {
                    args: TSEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: TSEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>;
                };
                findMany: {
                    args: TSEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>[];
                };
                findUnique: {
                    args: TSEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>;
                };
                groupBy: {
                    args: TSEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<TSEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: TSEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>;
                };
                updateMany: {
                    args: TSEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>[];
                };
                upsert: {
                    args: TSEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSEmbedFieldPayload>;
                };
            };
            payload: $TSEmbedFieldPayload<ExtArgs>;
        };
        TSMessageButton: {
            fields: TSMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: TSMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSMessageButton>;
                };
                count: {
                    args: TSMessageButtonCountArgs<ExtArgs>;
                    result: Optional<TSMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: TSMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>;
                };
                createMany: {
                    args: TSMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>[];
                };
                delete: {
                    args: TSMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>;
                };
                deleteMany: {
                    args: TSMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: TSMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>;
                };
                findMany: {
                    args: TSMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>[];
                };
                findUnique: {
                    args: TSMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>;
                };
                groupBy: {
                    args: TSMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<TSMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: TSMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>;
                };
                updateMany: {
                    args: TSMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>[];
                };
                upsert: {
                    args: TSMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageButtonPayload>;
                };
            };
            payload: $TSMessageButtonPayload<ExtArgs>;
        };
        TSMessageEmbed: {
            fields: TSMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: TSMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSMessageEmbed>;
                };
                count: {
                    args: TSMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<TSMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: TSMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>;
                };
                createMany: {
                    args: TSMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>[];
                };
                delete: {
                    args: TSMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>;
                };
                deleteMany: {
                    args: TSMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: TSMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>;
                };
                findMany: {
                    args: TSMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>[];
                };
                findUnique: {
                    args: TSMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>;
                };
                groupBy: {
                    args: TSMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<TSMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: TSMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>;
                };
                updateMany: {
                    args: TSMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>[];
                };
                upsert: {
                    args: TSMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageEmbedPayload>;
                };
            };
            payload: $TSMessageEmbedPayload<ExtArgs>;
        };
        TSMessageWebhook: {
            fields: TSMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: TSMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSMessageWebhook>;
                };
                count: {
                    args: TSMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<TSMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: TSMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>;
                };
                createMany: {
                    args: TSMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>[];
                };
                delete: {
                    args: TSMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>;
                };
                deleteMany: {
                    args: TSMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: TSMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>;
                };
                findMany: {
                    args: TSMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>[];
                };
                findUnique: {
                    args: TSMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>;
                };
                groupBy: {
                    args: TSMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<TSMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: TSMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>;
                };
                updateMany: {
                    args: TSMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>[];
                };
                upsert: {
                    args: TSMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSMessageWebhookPayload>;
                };
            };
            payload: $TSMessageWebhookPayload<ExtArgs>;
        };
        TSStatsChannelId: {
            fields: TSStatsChannelIdFieldRefs;
            operations: {
                aggregate: {
                    args: TSStatsChannelIdAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTSStatsChannelId>;
                };
                count: {
                    args: TSStatsChannelIdCountArgs<ExtArgs>;
                    result: Optional<TSStatsChannelIdCountAggregateOutputType> | number;
                };
                create: {
                    args: TSStatsChannelIdCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>;
                };
                createMany: {
                    args: TSStatsChannelIdCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TSStatsChannelIdCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>[];
                };
                delete: {
                    args: TSStatsChannelIdDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>;
                };
                deleteMany: {
                    args: TSStatsChannelIdDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TSStatsChannelIdFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload> | null;
                };
                findFirstOrThrow: {
                    args: TSStatsChannelIdFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>;
                };
                findMany: {
                    args: TSStatsChannelIdFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>[];
                };
                findUnique: {
                    args: TSStatsChannelIdFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TSStatsChannelIdFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>;
                };
                groupBy: {
                    args: TSStatsChannelIdGroupByArgs<ExtArgs>;
                    result: Optional<TSStatsChannelIdGroupByOutputType>[];
                };
                update: {
                    args: TSStatsChannelIdUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>;
                };
                updateMany: {
                    args: TSStatsChannelIdUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TSStatsChannelIdUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>[];
                };
                upsert: {
                    args: TSStatsChannelIdUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TSStatsChannelIdPayload>;
                };
            };
            payload: $TSStatsChannelIdPayload<ExtArgs>;
        };
        TTSCurrentlyLive: {
            fields: TTSCurrentlyLiveFieldRefs;
            operations: {
                aggregate: {
                    args: TTSCurrentlyLiveAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSCurrentlyLive>;
                };
                count: {
                    args: TTSCurrentlyLiveCountArgs<ExtArgs>;
                    result: Optional<TTSCurrentlyLiveCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSCurrentlyLiveCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>;
                };
                createMany: {
                    args: TTSCurrentlyLiveCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSCurrentlyLiveCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>[];
                };
                delete: {
                    args: TTSCurrentlyLiveDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>;
                };
                deleteMany: {
                    args: TTSCurrentlyLiveDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSCurrentlyLiveFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSCurrentlyLiveFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>;
                };
                findMany: {
                    args: TTSCurrentlyLiveFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>[];
                };
                findUnique: {
                    args: TTSCurrentlyLiveFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSCurrentlyLiveFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>;
                };
                groupBy: {
                    args: TTSCurrentlyLiveGroupByArgs<ExtArgs>;
                    result: Optional<TTSCurrentlyLiveGroupByOutputType>[];
                };
                update: {
                    args: TTSCurrentlyLiveUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>;
                };
                updateMany: {
                    args: TTSCurrentlyLiveUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSCurrentlyLiveUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>[];
                };
                upsert: {
                    args: TTSCurrentlyLiveUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCurrentlyLivePayload>;
                };
            };
            payload: $TTSCurrentlyLivePayload<ExtArgs>;
        };
        TTSCustomMessage: {
            fields: TTSCustomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: TTSCustomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSCustomMessage>;
                };
                count: {
                    args: TTSCustomMessageCountArgs<ExtArgs>;
                    result: Optional<TTSCustomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSCustomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>;
                };
                createMany: {
                    args: TTSCustomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSCustomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>[];
                };
                delete: {
                    args: TTSCustomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>;
                };
                deleteMany: {
                    args: TTSCustomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSCustomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSCustomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>;
                };
                findMany: {
                    args: TTSCustomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>[];
                };
                findUnique: {
                    args: TTSCustomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSCustomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>;
                };
                groupBy: {
                    args: TTSCustomMessageGroupByArgs<ExtArgs>;
                    result: Optional<TTSCustomMessageGroupByOutputType>[];
                };
                update: {
                    args: TTSCustomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>;
                };
                updateMany: {
                    args: TTSCustomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSCustomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>[];
                };
                upsert: {
                    args: TTSCustomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSCustomMessagePayload>;
                };
            };
            payload: $TTSCustomMessagePayload<ExtArgs>;
        };
        TTSEmbedField: {
            fields: TTSEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: TTSEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSEmbedField>;
                };
                count: {
                    args: TTSEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<TTSEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>;
                };
                createMany: {
                    args: TTSEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>[];
                };
                delete: {
                    args: TTSEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>;
                };
                deleteMany: {
                    args: TTSEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>;
                };
                findMany: {
                    args: TTSEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>[];
                };
                findUnique: {
                    args: TTSEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>;
                };
                groupBy: {
                    args: TTSEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<TTSEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: TTSEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>;
                };
                updateMany: {
                    args: TTSEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>[];
                };
                upsert: {
                    args: TTSEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSEmbedFieldPayload>;
                };
            };
            payload: $TTSEmbedFieldPayload<ExtArgs>;
        };
        TTSMessageButton: {
            fields: TTSMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: TTSMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSMessageButton>;
                };
                count: {
                    args: TTSMessageButtonCountArgs<ExtArgs>;
                    result: Optional<TTSMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>;
                };
                createMany: {
                    args: TTSMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>[];
                };
                delete: {
                    args: TTSMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>;
                };
                deleteMany: {
                    args: TTSMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>;
                };
                findMany: {
                    args: TTSMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>[];
                };
                findUnique: {
                    args: TTSMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>;
                };
                groupBy: {
                    args: TTSMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<TTSMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: TTSMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>;
                };
                updateMany: {
                    args: TTSMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>[];
                };
                upsert: {
                    args: TTSMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageButtonPayload>;
                };
            };
            payload: $TTSMessageButtonPayload<ExtArgs>;
        };
        TTSMessageEmbed: {
            fields: TTSMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: TTSMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSMessageEmbed>;
                };
                count: {
                    args: TTSMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<TTSMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>;
                };
                createMany: {
                    args: TTSMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>[];
                };
                delete: {
                    args: TTSMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>;
                };
                deleteMany: {
                    args: TTSMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>;
                };
                findMany: {
                    args: TTSMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>[];
                };
                findUnique: {
                    args: TTSMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>;
                };
                groupBy: {
                    args: TTSMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<TTSMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: TTSMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>;
                };
                updateMany: {
                    args: TTSMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>[];
                };
                upsert: {
                    args: TTSMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageEmbedPayload>;
                };
            };
            payload: $TTSMessageEmbedPayload<ExtArgs>;
        };
        TTSMessageWebhook: {
            fields: TTSMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: TTSMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSMessageWebhook>;
                };
                count: {
                    args: TTSMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<TTSMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>;
                };
                createMany: {
                    args: TTSMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>[];
                };
                delete: {
                    args: TTSMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>;
                };
                deleteMany: {
                    args: TTSMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>;
                };
                findMany: {
                    args: TTSMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>[];
                };
                findUnique: {
                    args: TTSMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>;
                };
                groupBy: {
                    args: TTSMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<TTSMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: TTSMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>;
                };
                updateMany: {
                    args: TTSMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>[];
                };
                upsert: {
                    args: TTSMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSMessageWebhookPayload>;
                };
            };
            payload: $TTSMessageWebhookPayload<ExtArgs>;
        };
        TTSStatsChannelId: {
            fields: TTSStatsChannelIdFieldRefs;
            operations: {
                aggregate: {
                    args: TTSStatsChannelIdAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTTSStatsChannelId>;
                };
                count: {
                    args: TTSStatsChannelIdCountArgs<ExtArgs>;
                    result: Optional<TTSStatsChannelIdCountAggregateOutputType> | number;
                };
                create: {
                    args: TTSStatsChannelIdCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>;
                };
                createMany: {
                    args: TTSStatsChannelIdCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TTSStatsChannelIdCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>[];
                };
                delete: {
                    args: TTSStatsChannelIdDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>;
                };
                deleteMany: {
                    args: TTSStatsChannelIdDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TTSStatsChannelIdFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload> | null;
                };
                findFirstOrThrow: {
                    args: TTSStatsChannelIdFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>;
                };
                findMany: {
                    args: TTSStatsChannelIdFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>[];
                };
                findUnique: {
                    args: TTSStatsChannelIdFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TTSStatsChannelIdFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>;
                };
                groupBy: {
                    args: TTSStatsChannelIdGroupByArgs<ExtArgs>;
                    result: Optional<TTSStatsChannelIdGroupByOutputType>[];
                };
                update: {
                    args: TTSStatsChannelIdUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>;
                };
                updateMany: {
                    args: TTSStatsChannelIdUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TTSStatsChannelIdUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>[];
                };
                upsert: {
                    args: TTSStatsChannelIdUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TTSStatsChannelIdPayload>;
                };
            };
            payload: $TTSStatsChannelIdPayload<ExtArgs>;
        };
        Team: {
            fields: TeamFieldRefs;
            operations: {
                aggregate: {
                    args: TeamAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTeam>;
                };
                count: {
                    args: TeamCountArgs<ExtArgs>;
                    result: Optional<TeamCountAggregateOutputType> | number;
                };
                create: {
                    args: TeamCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>;
                };
                createMany: {
                    args: TeamCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TeamCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>[];
                };
                delete: {
                    args: TeamDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>;
                };
                deleteMany: {
                    args: TeamDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TeamFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload> | null;
                };
                findFirstOrThrow: {
                    args: TeamFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>;
                };
                findMany: {
                    args: TeamFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>[];
                };
                findUnique: {
                    args: TeamFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TeamFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>;
                };
                groupBy: {
                    args: TeamGroupByArgs<ExtArgs>;
                    result: Optional<TeamGroupByOutputType>[];
                };
                update: {
                    args: TeamUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>;
                };
                updateMany: {
                    args: TeamUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TeamUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>[];
                };
                upsert: {
                    args: TeamUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TeamPayload>;
                };
            };
            payload: $TeamPayload<ExtArgs>;
        };
        TeamMember: {
            fields: TeamMemberFieldRefs;
            operations: {
                aggregate: {
                    args: TeamMemberAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTeamMember>;
                };
                count: {
                    args: TeamMemberCountArgs<ExtArgs>;
                    result: Optional<TeamMemberCountAggregateOutputType> | number;
                };
                create: {
                    args: TeamMemberCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>;
                };
                createMany: {
                    args: TeamMemberCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TeamMemberCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>[];
                };
                delete: {
                    args: TeamMemberDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>;
                };
                deleteMany: {
                    args: TeamMemberDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TeamMemberFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload> | null;
                };
                findFirstOrThrow: {
                    args: TeamMemberFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>;
                };
                findMany: {
                    args: TeamMemberFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>[];
                };
                findUnique: {
                    args: TeamMemberFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TeamMemberFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>;
                };
                groupBy: {
                    args: TeamMemberGroupByArgs<ExtArgs>;
                    result: Optional<TeamMemberGroupByOutputType>[];
                };
                update: {
                    args: TeamMemberUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>;
                };
                updateMany: {
                    args: TeamMemberUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TeamMemberUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>[];
                };
                upsert: {
                    args: TeamMemberUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TeamMemberPayload>;
                };
            };
            payload: $TeamMemberPayload<ExtArgs>;
        };
        TiktokStreamer: {
            fields: TiktokStreamerFieldRefs;
            operations: {
                aggregate: {
                    args: TiktokStreamerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTiktokStreamer>;
                };
                count: {
                    args: TiktokStreamerCountArgs<ExtArgs>;
                    result: Optional<TiktokStreamerCountAggregateOutputType> | number;
                };
                create: {
                    args: TiktokStreamerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>;
                };
                createMany: {
                    args: TiktokStreamerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TiktokStreamerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>[];
                };
                delete: {
                    args: TiktokStreamerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>;
                };
                deleteMany: {
                    args: TiktokStreamerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TiktokStreamerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload> | null;
                };
                findFirstOrThrow: {
                    args: TiktokStreamerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>;
                };
                findMany: {
                    args: TiktokStreamerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>[];
                };
                findUnique: {
                    args: TiktokStreamerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TiktokStreamerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>;
                };
                groupBy: {
                    args: TiktokStreamerGroupByArgs<ExtArgs>;
                    result: Optional<TiktokStreamerGroupByOutputType>[];
                };
                update: {
                    args: TiktokStreamerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>;
                };
                updateMany: {
                    args: TiktokStreamerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TiktokStreamerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>[];
                };
                upsert: {
                    args: TiktokStreamerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TiktokStreamerPayload>;
                };
            };
            payload: $TiktokStreamerPayload<ExtArgs>;
        };
        TwitchStreamer: {
            fields: TwitchStreamerFieldRefs;
            operations: {
                aggregate: {
                    args: TwitchStreamerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateTwitchStreamer>;
                };
                count: {
                    args: TwitchStreamerCountArgs<ExtArgs>;
                    result: Optional<TwitchStreamerCountAggregateOutputType> | number;
                };
                create: {
                    args: TwitchStreamerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>;
                };
                createMany: {
                    args: TwitchStreamerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: TwitchStreamerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>[];
                };
                delete: {
                    args: TwitchStreamerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>;
                };
                deleteMany: {
                    args: TwitchStreamerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: TwitchStreamerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload> | null;
                };
                findFirstOrThrow: {
                    args: TwitchStreamerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>;
                };
                findMany: {
                    args: TwitchStreamerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>[];
                };
                findUnique: {
                    args: TwitchStreamerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: TwitchStreamerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>;
                };
                groupBy: {
                    args: TwitchStreamerGroupByArgs<ExtArgs>;
                    result: Optional<TwitchStreamerGroupByOutputType>[];
                };
                update: {
                    args: TwitchStreamerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>;
                };
                updateMany: {
                    args: TwitchStreamerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: TwitchStreamerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>[];
                };
                upsert: {
                    args: TwitchStreamerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$TwitchStreamerPayload>;
                };
            };
            payload: $TwitchStreamerPayload<ExtArgs>;
        };
        User: {
            fields: UserFieldRefs;
            operations: {
                aggregate: {
                    args: UserAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUser>;
                };
                count: {
                    args: UserCountArgs<ExtArgs>;
                    result: Optional<UserCountAggregateOutputType> | number;
                };
                create: {
                    args: UserCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>;
                };
                createMany: {
                    args: UserCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>[];
                };
                delete: {
                    args: UserDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>;
                };
                deleteMany: {
                    args: UserDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>;
                };
                findMany: {
                    args: UserFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>[];
                };
                findUnique: {
                    args: UserFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>;
                };
                groupBy: {
                    args: UserGroupByArgs<ExtArgs>;
                    result: Optional<UserGroupByOutputType>[];
                };
                update: {
                    args: UserUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>;
                };
                updateMany: {
                    args: UserUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>[];
                };
                upsert: {
                    args: UserUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserPayload>;
                };
            };
            payload: $UserPayload<ExtArgs>;
        };
        UserActiveGuildSubscription: {
            fields: UserActiveGuildSubscriptionFieldRefs;
            operations: {
                aggregate: {
                    args: UserActiveGuildSubscriptionAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserActiveGuildSubscription>;
                };
                count: {
                    args: UserActiveGuildSubscriptionCountArgs<ExtArgs>;
                    result: Optional<UserActiveGuildSubscriptionCountAggregateOutputType> | number;
                };
                create: {
                    args: UserActiveGuildSubscriptionCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>;
                };
                createMany: {
                    args: UserActiveGuildSubscriptionCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserActiveGuildSubscriptionCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>[];
                };
                delete: {
                    args: UserActiveGuildSubscriptionDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>;
                };
                deleteMany: {
                    args: UserActiveGuildSubscriptionDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserActiveGuildSubscriptionFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserActiveGuildSubscriptionFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>;
                };
                findMany: {
                    args: UserActiveGuildSubscriptionFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>[];
                };
                findUnique: {
                    args: UserActiveGuildSubscriptionFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserActiveGuildSubscriptionFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>;
                };
                groupBy: {
                    args: UserActiveGuildSubscriptionGroupByArgs<ExtArgs>;
                    result: Optional<UserActiveGuildSubscriptionGroupByOutputType>[];
                };
                update: {
                    args: UserActiveGuildSubscriptionUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>;
                };
                updateMany: {
                    args: UserActiveGuildSubscriptionUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserActiveGuildSubscriptionUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>[];
                };
                upsert: {
                    args: UserActiveGuildSubscriptionUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserActiveGuildSubscriptionPayload>;
                };
            };
            payload: $UserActiveGuildSubscriptionPayload<ExtArgs>;
        };
        UserBirthday: {
            fields: UserBirthdayFieldRefs;
            operations: {
                aggregate: {
                    args: UserBirthdayAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserBirthday>;
                };
                count: {
                    args: UserBirthdayCountArgs<ExtArgs>;
                    result: Optional<UserBirthdayCountAggregateOutputType> | number;
                };
                create: {
                    args: UserBirthdayCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>;
                };
                createMany: {
                    args: UserBirthdayCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserBirthdayCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>[];
                };
                delete: {
                    args: UserBirthdayDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>;
                };
                deleteMany: {
                    args: UserBirthdayDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserBirthdayFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserBirthdayFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>;
                };
                findMany: {
                    args: UserBirthdayFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>[];
                };
                findUnique: {
                    args: UserBirthdayFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserBirthdayFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>;
                };
                groupBy: {
                    args: UserBirthdayGroupByArgs<ExtArgs>;
                    result: Optional<UserBirthdayGroupByOutputType>[];
                };
                update: {
                    args: UserBirthdayUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>;
                };
                updateMany: {
                    args: UserBirthdayUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserBirthdayUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>[];
                };
                upsert: {
                    args: UserBirthdayUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserBirthdayPayload>;
                };
            };
            payload: $UserBirthdayPayload<ExtArgs>;
        };
        UserGettingStarted: {
            fields: UserGettingStartedFieldRefs;
            operations: {
                aggregate: {
                    args: UserGettingStartedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserGettingStarted>;
                };
                count: {
                    args: UserGettingStartedCountArgs<ExtArgs>;
                    result: Optional<UserGettingStartedCountAggregateOutputType> | number;
                };
                create: {
                    args: UserGettingStartedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>;
                };
                createMany: {
                    args: UserGettingStartedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserGettingStartedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>[];
                };
                delete: {
                    args: UserGettingStartedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>;
                };
                deleteMany: {
                    args: UserGettingStartedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserGettingStartedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserGettingStartedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>;
                };
                findMany: {
                    args: UserGettingStartedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>[];
                };
                findUnique: {
                    args: UserGettingStartedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserGettingStartedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>;
                };
                groupBy: {
                    args: UserGettingStartedGroupByArgs<ExtArgs>;
                    result: Optional<UserGettingStartedGroupByOutputType>[];
                };
                update: {
                    args: UserGettingStartedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>;
                };
                updateMany: {
                    args: UserGettingStartedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserGettingStartedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>[];
                };
                upsert: {
                    args: UserGettingStartedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserGettingStartedPayload>;
                };
            };
            payload: $UserGettingStartedPayload<ExtArgs>;
        };
        UserKickAccount: {
            fields: UserKickAccountFieldRefs;
            operations: {
                aggregate: {
                    args: UserKickAccountAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserKickAccount>;
                };
                count: {
                    args: UserKickAccountCountArgs<ExtArgs>;
                    result: Optional<UserKickAccountCountAggregateOutputType> | number;
                };
                create: {
                    args: UserKickAccountCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>;
                };
                createMany: {
                    args: UserKickAccountCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserKickAccountCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>[];
                };
                delete: {
                    args: UserKickAccountDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>;
                };
                deleteMany: {
                    args: UserKickAccountDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserKickAccountFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserKickAccountFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>;
                };
                findMany: {
                    args: UserKickAccountFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>[];
                };
                findUnique: {
                    args: UserKickAccountFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserKickAccountFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>;
                };
                groupBy: {
                    args: UserKickAccountGroupByArgs<ExtArgs>;
                    result: Optional<UserKickAccountGroupByOutputType>[];
                };
                update: {
                    args: UserKickAccountUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>;
                };
                updateMany: {
                    args: UserKickAccountUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserKickAccountUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>[];
                };
                upsert: {
                    args: UserKickAccountUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountPayload>;
                };
            };
            payload: $UserKickAccountPayload<ExtArgs>;
        };
        UserKickAccountSubscribedTo: {
            fields: UserKickAccountSubscribedToFieldRefs;
            operations: {
                aggregate: {
                    args: UserKickAccountSubscribedToAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserKickAccountSubscribedTo>;
                };
                count: {
                    args: UserKickAccountSubscribedToCountArgs<ExtArgs>;
                    result: Optional<UserKickAccountSubscribedToCountAggregateOutputType> | number;
                };
                create: {
                    args: UserKickAccountSubscribedToCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>;
                };
                createMany: {
                    args: UserKickAccountSubscribedToCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserKickAccountSubscribedToCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>[];
                };
                delete: {
                    args: UserKickAccountSubscribedToDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>;
                };
                deleteMany: {
                    args: UserKickAccountSubscribedToDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserKickAccountSubscribedToFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserKickAccountSubscribedToFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>;
                };
                findMany: {
                    args: UserKickAccountSubscribedToFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>[];
                };
                findUnique: {
                    args: UserKickAccountSubscribedToFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserKickAccountSubscribedToFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>;
                };
                groupBy: {
                    args: UserKickAccountSubscribedToGroupByArgs<ExtArgs>;
                    result: Optional<UserKickAccountSubscribedToGroupByOutputType>[];
                };
                update: {
                    args: UserKickAccountSubscribedToUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>;
                };
                updateMany: {
                    args: UserKickAccountSubscribedToUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserKickAccountSubscribedToUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>[];
                };
                upsert: {
                    args: UserKickAccountSubscribedToUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserKickAccountSubscribedToPayload>;
                };
            };
            payload: $UserKickAccountSubscribedToPayload<ExtArgs>;
        };
        UserLinkedRoles: {
            fields: UserLinkedRolesFieldRefs;
            operations: {
                aggregate: {
                    args: UserLinkedRolesAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserLinkedRoles>;
                };
                count: {
                    args: UserLinkedRolesCountArgs<ExtArgs>;
                    result: Optional<UserLinkedRolesCountAggregateOutputType> | number;
                };
                create: {
                    args: UserLinkedRolesCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>;
                };
                createMany: {
                    args: UserLinkedRolesCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserLinkedRolesCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>[];
                };
                delete: {
                    args: UserLinkedRolesDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>;
                };
                deleteMany: {
                    args: UserLinkedRolesDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserLinkedRolesFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserLinkedRolesFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>;
                };
                findMany: {
                    args: UserLinkedRolesFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>[];
                };
                findUnique: {
                    args: UserLinkedRolesFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserLinkedRolesFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>;
                };
                groupBy: {
                    args: UserLinkedRolesGroupByArgs<ExtArgs>;
                    result: Optional<UserLinkedRolesGroupByOutputType>[];
                };
                update: {
                    args: UserLinkedRolesUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>;
                };
                updateMany: {
                    args: UserLinkedRolesUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserLinkedRolesUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>[];
                };
                upsert: {
                    args: UserLinkedRolesUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserLinkedRolesPayload>;
                };
            };
            payload: $UserLinkedRolesPayload<ExtArgs>;
        };
        UserMediaShare: {
            fields: UserMediaShareFieldRefs;
            operations: {
                aggregate: {
                    args: UserMediaShareAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserMediaShare>;
                };
                count: {
                    args: UserMediaShareCountArgs<ExtArgs>;
                    result: Optional<UserMediaShareCountAggregateOutputType> | number;
                };
                create: {
                    args: UserMediaShareCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>;
                };
                createMany: {
                    args: UserMediaShareCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserMediaShareCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>[];
                };
                delete: {
                    args: UserMediaShareDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>;
                };
                deleteMany: {
                    args: UserMediaShareDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserMediaShareFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload> | null;
                };
                findFirstOrThrow: {
                    args: UserMediaShareFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>;
                };
                findMany: {
                    args: UserMediaShareFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>[];
                };
                findUnique: {
                    args: UserMediaShareFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserMediaShareFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>;
                };
                groupBy: {
                    args: UserMediaShareGroupByArgs<ExtArgs>;
                    result: Optional<UserMediaShareGroupByOutputType>[];
                };
                update: {
                    args: UserMediaShareUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>;
                };
                updateMany: {
                    args: UserMediaShareUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserMediaShareUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>[];
                };
                upsert: {
                    args: UserMediaShareUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePayload>;
                };
            };
            payload: $UserMediaSharePayload<ExtArgs>;
        };
        UserMediaSharePermissions: {
            fields: UserMediaSharePermissionsFieldRefs;
            operations: {
                aggregate: {
                    args: UserMediaSharePermissionsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserMediaSharePermissions>;
                };
                count: {
                    args: UserMediaSharePermissionsCountArgs<ExtArgs>;
                    result: Optional<UserMediaSharePermissionsCountAggregateOutputType> | number;
                };
                create: {
                    args: UserMediaSharePermissionsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>;
                };
                createMany: {
                    args: UserMediaSharePermissionsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserMediaSharePermissionsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>[];
                };
                delete: {
                    args: UserMediaSharePermissionsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>;
                };
                deleteMany: {
                    args: UserMediaSharePermissionsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserMediaSharePermissionsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserMediaSharePermissionsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>;
                };
                findMany: {
                    args: UserMediaSharePermissionsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>[];
                };
                findUnique: {
                    args: UserMediaSharePermissionsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserMediaSharePermissionsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>;
                };
                groupBy: {
                    args: UserMediaSharePermissionsGroupByArgs<ExtArgs>;
                    result: Optional<UserMediaSharePermissionsGroupByOutputType>[];
                };
                update: {
                    args: UserMediaSharePermissionsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>;
                };
                updateMany: {
                    args: UserMediaSharePermissionsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserMediaSharePermissionsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>[];
                };
                upsert: {
                    args: UserMediaSharePermissionsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaSharePermissionsPayload>;
                };
            };
            payload: $UserMediaSharePermissionsPayload<ExtArgs>;
        };
        UserMediaShareSettings: {
            fields: UserMediaShareSettingsFieldRefs;
            operations: {
                aggregate: {
                    args: UserMediaShareSettingsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserMediaShareSettings>;
                };
                count: {
                    args: UserMediaShareSettingsCountArgs<ExtArgs>;
                    result: Optional<UserMediaShareSettingsCountAggregateOutputType> | number;
                };
                create: {
                    args: UserMediaShareSettingsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>;
                };
                createMany: {
                    args: UserMediaShareSettingsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserMediaShareSettingsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>[];
                };
                delete: {
                    args: UserMediaShareSettingsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>;
                };
                deleteMany: {
                    args: UserMediaShareSettingsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserMediaShareSettingsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserMediaShareSettingsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>;
                };
                findMany: {
                    args: UserMediaShareSettingsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>[];
                };
                findUnique: {
                    args: UserMediaShareSettingsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserMediaShareSettingsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>;
                };
                groupBy: {
                    args: UserMediaShareSettingsGroupByArgs<ExtArgs>;
                    result: Optional<UserMediaShareSettingsGroupByOutputType>[];
                };
                update: {
                    args: UserMediaShareSettingsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>;
                };
                updateMany: {
                    args: UserMediaShareSettingsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserMediaShareSettingsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>[];
                };
                upsert: {
                    args: UserMediaShareSettingsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserMediaShareSettingsPayload>;
                };
            };
            payload: $UserMediaShareSettingsPayload<ExtArgs>;
        };
        UserNotificationData: {
            fields: UserNotificationDataFieldRefs;
            operations: {
                aggregate: {
                    args: UserNotificationDataAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserNotificationData>;
                };
                count: {
                    args: UserNotificationDataCountArgs<ExtArgs>;
                    result: Optional<UserNotificationDataCountAggregateOutputType> | number;
                };
                create: {
                    args: UserNotificationDataCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>;
                };
                createMany: {
                    args: UserNotificationDataCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserNotificationDataCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>[];
                };
                delete: {
                    args: UserNotificationDataDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>;
                };
                deleteMany: {
                    args: UserNotificationDataDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserNotificationDataFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserNotificationDataFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>;
                };
                findMany: {
                    args: UserNotificationDataFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>[];
                };
                findUnique: {
                    args: UserNotificationDataFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserNotificationDataFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>;
                };
                groupBy: {
                    args: UserNotificationDataGroupByArgs<ExtArgs>;
                    result: Optional<UserNotificationDataGroupByOutputType>[];
                };
                update: {
                    args: UserNotificationDataUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>;
                };
                updateMany: {
                    args: UserNotificationDataUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserNotificationDataUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>[];
                };
                upsert: {
                    args: UserNotificationDataUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationDataPayload>;
                };
            };
            payload: $UserNotificationDataPayload<ExtArgs>;
        };
        UserNotifications: {
            fields: UserNotificationsFieldRefs;
            operations: {
                aggregate: {
                    args: UserNotificationsAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserNotifications>;
                };
                count: {
                    args: UserNotificationsCountArgs<ExtArgs>;
                    result: Optional<UserNotificationsCountAggregateOutputType> | number;
                };
                create: {
                    args: UserNotificationsCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>;
                };
                createMany: {
                    args: UserNotificationsCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserNotificationsCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>[];
                };
                delete: {
                    args: UserNotificationsDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>;
                };
                deleteMany: {
                    args: UserNotificationsDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserNotificationsFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserNotificationsFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>;
                };
                findMany: {
                    args: UserNotificationsFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>[];
                };
                findUnique: {
                    args: UserNotificationsFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserNotificationsFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>;
                };
                groupBy: {
                    args: UserNotificationsGroupByArgs<ExtArgs>;
                    result: Optional<UserNotificationsGroupByOutputType>[];
                };
                update: {
                    args: UserNotificationsUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>;
                };
                updateMany: {
                    args: UserNotificationsUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserNotificationsUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>[];
                };
                upsert: {
                    args: UserNotificationsUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserNotificationsPayload>;
                };
            };
            payload: $UserNotificationsPayload<ExtArgs>;
        };
        UserPremium: {
            fields: UserPremiumFieldRefs;
            operations: {
                aggregate: {
                    args: UserPremiumAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserPremium>;
                };
                count: {
                    args: UserPremiumCountArgs<ExtArgs>;
                    result: Optional<UserPremiumCountAggregateOutputType> | number;
                };
                create: {
                    args: UserPremiumCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>;
                };
                createMany: {
                    args: UserPremiumCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserPremiumCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>[];
                };
                delete: {
                    args: UserPremiumDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>;
                };
                deleteMany: {
                    args: UserPremiumDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserPremiumFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserPremiumFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>;
                };
                findMany: {
                    args: UserPremiumFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>[];
                };
                findUnique: {
                    args: UserPremiumFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserPremiumFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>;
                };
                groupBy: {
                    args: UserPremiumGroupByArgs<ExtArgs>;
                    result: Optional<UserPremiumGroupByOutputType>[];
                };
                update: {
                    args: UserPremiumUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>;
                };
                updateMany: {
                    args: UserPremiumUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserPremiumUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>[];
                };
                upsert: {
                    args: UserPremiumUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserPremiumPayload>;
                };
            };
            payload: $UserPremiumPayload<ExtArgs>;
        };
        UserRumbleAccount: {
            fields: UserRumbleAccountFieldRefs;
            operations: {
                aggregate: {
                    args: UserRumbleAccountAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserRumbleAccount>;
                };
                count: {
                    args: UserRumbleAccountCountArgs<ExtArgs>;
                    result: Optional<UserRumbleAccountCountAggregateOutputType> | number;
                };
                create: {
                    args: UserRumbleAccountCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>;
                };
                createMany: {
                    args: UserRumbleAccountCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserRumbleAccountCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>[];
                };
                delete: {
                    args: UserRumbleAccountDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>;
                };
                deleteMany: {
                    args: UserRumbleAccountDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserRumbleAccountFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserRumbleAccountFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>;
                };
                findMany: {
                    args: UserRumbleAccountFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>[];
                };
                findUnique: {
                    args: UserRumbleAccountFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserRumbleAccountFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>;
                };
                groupBy: {
                    args: UserRumbleAccountGroupByArgs<ExtArgs>;
                    result: Optional<UserRumbleAccountGroupByOutputType>[];
                };
                update: {
                    args: UserRumbleAccountUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>;
                };
                updateMany: {
                    args: UserRumbleAccountUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserRumbleAccountUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>[];
                };
                upsert: {
                    args: UserRumbleAccountUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserRumbleAccountPayload>;
                };
            };
            payload: $UserRumbleAccountPayload<ExtArgs>;
        };
        UserSession: {
            fields: UserSessionFieldRefs;
            operations: {
                aggregate: {
                    args: UserSessionAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserSession>;
                };
                count: {
                    args: UserSessionCountArgs<ExtArgs>;
                    result: Optional<UserSessionCountAggregateOutputType> | number;
                };
                create: {
                    args: UserSessionCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>;
                };
                createMany: {
                    args: UserSessionCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserSessionCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>[];
                };
                delete: {
                    args: UserSessionDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>;
                };
                deleteMany: {
                    args: UserSessionDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserSessionFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserSessionFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>;
                };
                findMany: {
                    args: UserSessionFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>[];
                };
                findUnique: {
                    args: UserSessionFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserSessionFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>;
                };
                groupBy: {
                    args: UserSessionGroupByArgs<ExtArgs>;
                    result: Optional<UserSessionGroupByOutputType>[];
                };
                update: {
                    args: UserSessionUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>;
                };
                updateMany: {
                    args: UserSessionUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserSessionUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>[];
                };
                upsert: {
                    args: UserSessionUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserSessionPayload>;
                };
            };
            payload: $UserSessionPayload<ExtArgs>;
        };
        UserTwitchAccount: {
            fields: UserTwitchAccountFieldRefs;
            operations: {
                aggregate: {
                    args: UserTwitchAccountAggregateArgs<ExtArgs>;
                    result: Optional<AggregateUserTwitchAccount>;
                };
                count: {
                    args: UserTwitchAccountCountArgs<ExtArgs>;
                    result: Optional<UserTwitchAccountCountAggregateOutputType> | number;
                };
                create: {
                    args: UserTwitchAccountCreateArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>;
                };
                createMany: {
                    args: UserTwitchAccountCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: UserTwitchAccountCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>[];
                };
                delete: {
                    args: UserTwitchAccountDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>;
                };
                deleteMany: {
                    args: UserTwitchAccountDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: UserTwitchAccountFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload> | null;
                };
                findFirstOrThrow: {
                    args: UserTwitchAccountFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>;
                };
                findMany: {
                    args: UserTwitchAccountFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>[];
                };
                findUnique: {
                    args: UserTwitchAccountFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload> | null;
                };
                findUniqueOrThrow: {
                    args: UserTwitchAccountFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>;
                };
                groupBy: {
                    args: UserTwitchAccountGroupByArgs<ExtArgs>;
                    result: Optional<UserTwitchAccountGroupByOutputType>[];
                };
                update: {
                    args: UserTwitchAccountUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>;
                };
                updateMany: {
                    args: UserTwitchAccountUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: UserTwitchAccountUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>[];
                };
                upsert: {
                    args: UserTwitchAccountUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$UserTwitchAccountPayload>;
                };
            };
            payload: $UserTwitchAccountPayload<ExtArgs>;
        };
        YTSCurrentlyLive: {
            fields: YTSCurrentlyLiveFieldRefs;
            operations: {
                aggregate: {
                    args: YTSCurrentlyLiveAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSCurrentlyLive>;
                };
                count: {
                    args: YTSCurrentlyLiveCountArgs<ExtArgs>;
                    result: Optional<YTSCurrentlyLiveCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSCurrentlyLiveCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>;
                };
                createMany: {
                    args: YTSCurrentlyLiveCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSCurrentlyLiveCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>[];
                };
                delete: {
                    args: YTSCurrentlyLiveDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>;
                };
                deleteMany: {
                    args: YTSCurrentlyLiveDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSCurrentlyLiveFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSCurrentlyLiveFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>;
                };
                findMany: {
                    args: YTSCurrentlyLiveFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>[];
                };
                findUnique: {
                    args: YTSCurrentlyLiveFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSCurrentlyLiveFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>;
                };
                groupBy: {
                    args: YTSCurrentlyLiveGroupByArgs<ExtArgs>;
                    result: Optional<YTSCurrentlyLiveGroupByOutputType>[];
                };
                update: {
                    args: YTSCurrentlyLiveUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>;
                };
                updateMany: {
                    args: YTSCurrentlyLiveUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSCurrentlyLiveUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>[];
                };
                upsert: {
                    args: YTSCurrentlyLiveUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCurrentlyLivePayload>;
                };
            };
            payload: $YTSCurrentlyLivePayload<ExtArgs>;
        };
        YTSCustomMessage: {
            fields: YTSCustomMessageFieldRefs;
            operations: {
                aggregate: {
                    args: YTSCustomMessageAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSCustomMessage>;
                };
                count: {
                    args: YTSCustomMessageCountArgs<ExtArgs>;
                    result: Optional<YTSCustomMessageCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSCustomMessageCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>;
                };
                createMany: {
                    args: YTSCustomMessageCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSCustomMessageCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>[];
                };
                delete: {
                    args: YTSCustomMessageDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>;
                };
                deleteMany: {
                    args: YTSCustomMessageDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSCustomMessageFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSCustomMessageFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>;
                };
                findMany: {
                    args: YTSCustomMessageFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>[];
                };
                findUnique: {
                    args: YTSCustomMessageFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSCustomMessageFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>;
                };
                groupBy: {
                    args: YTSCustomMessageGroupByArgs<ExtArgs>;
                    result: Optional<YTSCustomMessageGroupByOutputType>[];
                };
                update: {
                    args: YTSCustomMessageUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>;
                };
                updateMany: {
                    args: YTSCustomMessageUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSCustomMessageUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>[];
                };
                upsert: {
                    args: YTSCustomMessageUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSCustomMessagePayload>;
                };
            };
            payload: $YTSCustomMessagePayload<ExtArgs>;
        };
        YTSEmbedField: {
            fields: YTSEmbedFieldFieldRefs;
            operations: {
                aggregate: {
                    args: YTSEmbedFieldAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSEmbedField>;
                };
                count: {
                    args: YTSEmbedFieldCountArgs<ExtArgs>;
                    result: Optional<YTSEmbedFieldCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSEmbedFieldCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>;
                };
                createMany: {
                    args: YTSEmbedFieldCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSEmbedFieldCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>[];
                };
                delete: {
                    args: YTSEmbedFieldDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>;
                };
                deleteMany: {
                    args: YTSEmbedFieldDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSEmbedFieldFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSEmbedFieldFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>;
                };
                findMany: {
                    args: YTSEmbedFieldFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>[];
                };
                findUnique: {
                    args: YTSEmbedFieldFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSEmbedFieldFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>;
                };
                groupBy: {
                    args: YTSEmbedFieldGroupByArgs<ExtArgs>;
                    result: Optional<YTSEmbedFieldGroupByOutputType>[];
                };
                update: {
                    args: YTSEmbedFieldUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>;
                };
                updateMany: {
                    args: YTSEmbedFieldUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSEmbedFieldUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>[];
                };
                upsert: {
                    args: YTSEmbedFieldUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSEmbedFieldPayload>;
                };
            };
            payload: $YTSEmbedFieldPayload<ExtArgs>;
        };
        YTSMessageButton: {
            fields: YTSMessageButtonFieldRefs;
            operations: {
                aggregate: {
                    args: YTSMessageButtonAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSMessageButton>;
                };
                count: {
                    args: YTSMessageButtonCountArgs<ExtArgs>;
                    result: Optional<YTSMessageButtonCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSMessageButtonCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>;
                };
                createMany: {
                    args: YTSMessageButtonCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSMessageButtonCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>[];
                };
                delete: {
                    args: YTSMessageButtonDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>;
                };
                deleteMany: {
                    args: YTSMessageButtonDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSMessageButtonFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSMessageButtonFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>;
                };
                findMany: {
                    args: YTSMessageButtonFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>[];
                };
                findUnique: {
                    args: YTSMessageButtonFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSMessageButtonFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>;
                };
                groupBy: {
                    args: YTSMessageButtonGroupByArgs<ExtArgs>;
                    result: Optional<YTSMessageButtonGroupByOutputType>[];
                };
                update: {
                    args: YTSMessageButtonUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>;
                };
                updateMany: {
                    args: YTSMessageButtonUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSMessageButtonUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>[];
                };
                upsert: {
                    args: YTSMessageButtonUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageButtonPayload>;
                };
            };
            payload: $YTSMessageButtonPayload<ExtArgs>;
        };
        YTSMessageEmbed: {
            fields: YTSMessageEmbedFieldRefs;
            operations: {
                aggregate: {
                    args: YTSMessageEmbedAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSMessageEmbed>;
                };
                count: {
                    args: YTSMessageEmbedCountArgs<ExtArgs>;
                    result: Optional<YTSMessageEmbedCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSMessageEmbedCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>;
                };
                createMany: {
                    args: YTSMessageEmbedCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSMessageEmbedCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>[];
                };
                delete: {
                    args: YTSMessageEmbedDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>;
                };
                deleteMany: {
                    args: YTSMessageEmbedDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSMessageEmbedFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSMessageEmbedFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>;
                };
                findMany: {
                    args: YTSMessageEmbedFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>[];
                };
                findUnique: {
                    args: YTSMessageEmbedFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSMessageEmbedFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>;
                };
                groupBy: {
                    args: YTSMessageEmbedGroupByArgs<ExtArgs>;
                    result: Optional<YTSMessageEmbedGroupByOutputType>[];
                };
                update: {
                    args: YTSMessageEmbedUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>;
                };
                updateMany: {
                    args: YTSMessageEmbedUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSMessageEmbedUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>[];
                };
                upsert: {
                    args: YTSMessageEmbedUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageEmbedPayload>;
                };
            };
            payload: $YTSMessageEmbedPayload<ExtArgs>;
        };
        YTSMessageWebhook: {
            fields: YTSMessageWebhookFieldRefs;
            operations: {
                aggregate: {
                    args: YTSMessageWebhookAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSMessageWebhook>;
                };
                count: {
                    args: YTSMessageWebhookCountArgs<ExtArgs>;
                    result: Optional<YTSMessageWebhookCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSMessageWebhookCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>;
                };
                createMany: {
                    args: YTSMessageWebhookCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSMessageWebhookCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>[];
                };
                delete: {
                    args: YTSMessageWebhookDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>;
                };
                deleteMany: {
                    args: YTSMessageWebhookDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSMessageWebhookFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSMessageWebhookFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>;
                };
                findMany: {
                    args: YTSMessageWebhookFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>[];
                };
                findUnique: {
                    args: YTSMessageWebhookFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSMessageWebhookFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>;
                };
                groupBy: {
                    args: YTSMessageWebhookGroupByArgs<ExtArgs>;
                    result: Optional<YTSMessageWebhookGroupByOutputType>[];
                };
                update: {
                    args: YTSMessageWebhookUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>;
                };
                updateMany: {
                    args: YTSMessageWebhookUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSMessageWebhookUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>[];
                };
                upsert: {
                    args: YTSMessageWebhookUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSMessageWebhookPayload>;
                };
            };
            payload: $YTSMessageWebhookPayload<ExtArgs>;
        };
        YTSStatsChannelId: {
            fields: YTSStatsChannelIdFieldRefs;
            operations: {
                aggregate: {
                    args: YTSStatsChannelIdAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYTSStatsChannelId>;
                };
                count: {
                    args: YTSStatsChannelIdCountArgs<ExtArgs>;
                    result: Optional<YTSStatsChannelIdCountAggregateOutputType> | number;
                };
                create: {
                    args: YTSStatsChannelIdCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>;
                };
                createMany: {
                    args: YTSStatsChannelIdCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YTSStatsChannelIdCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>[];
                };
                delete: {
                    args: YTSStatsChannelIdDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>;
                };
                deleteMany: {
                    args: YTSStatsChannelIdDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YTSStatsChannelIdFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload> | null;
                };
                findFirstOrThrow: {
                    args: YTSStatsChannelIdFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>;
                };
                findMany: {
                    args: YTSStatsChannelIdFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>[];
                };
                findUnique: {
                    args: YTSStatsChannelIdFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload> | null;
                };
                findUniqueOrThrow: {
                    args: YTSStatsChannelIdFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>;
                };
                groupBy: {
                    args: YTSStatsChannelIdGroupByArgs<ExtArgs>;
                    result: Optional<YTSStatsChannelIdGroupByOutputType>[];
                };
                update: {
                    args: YTSStatsChannelIdUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>;
                };
                updateMany: {
                    args: YTSStatsChannelIdUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YTSStatsChannelIdUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>[];
                };
                upsert: {
                    args: YTSStatsChannelIdUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YTSStatsChannelIdPayload>;
                };
            };
            payload: $YTSStatsChannelIdPayload<ExtArgs>;
        };
        YoutubeStreamer: {
            fields: YoutubeStreamerFieldRefs;
            operations: {
                aggregate: {
                    args: YoutubeStreamerAggregateArgs<ExtArgs>;
                    result: Optional<AggregateYoutubeStreamer>;
                };
                count: {
                    args: YoutubeStreamerCountArgs<ExtArgs>;
                    result: Optional<YoutubeStreamerCountAggregateOutputType> | number;
                };
                create: {
                    args: YoutubeStreamerCreateArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>;
                };
                createMany: {
                    args: YoutubeStreamerCreateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                createManyAndReturn: {
                    args: YoutubeStreamerCreateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>[];
                };
                delete: {
                    args: YoutubeStreamerDeleteArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>;
                };
                deleteMany: {
                    args: YoutubeStreamerDeleteManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                findFirst: {
                    args: YoutubeStreamerFindFirstArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload> | null;
                };
                findFirstOrThrow: {
                    args: YoutubeStreamerFindFirstOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>;
                };
                findMany: {
                    args: YoutubeStreamerFindManyArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>[];
                };
                findUnique: {
                    args: YoutubeStreamerFindUniqueArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload> | null;
                };
                findUniqueOrThrow: {
                    args: YoutubeStreamerFindUniqueOrThrowArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>;
                };
                groupBy: {
                    args: YoutubeStreamerGroupByArgs<ExtArgs>;
                    result: Optional<YoutubeStreamerGroupByOutputType>[];
                };
                update: {
                    args: YoutubeStreamerUpdateArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>;
                };
                updateMany: {
                    args: YoutubeStreamerUpdateManyArgs<ExtArgs>;
                    result: BatchPayload;
                };
                updateManyAndReturn: {
                    args: YoutubeStreamerUpdateManyAndReturnArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>[];
                };
                upsert: {
                    args: YoutubeStreamerUpsertArgs<ExtArgs>;
                    result: PayloadToResult<$YoutubeStreamerPayload>;
                };
            };
            payload: $YoutubeStreamerPayload<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;
    };
}

Type Parameters

ExtArgs extends InternalArgs = DefaultArgs
GlobalOmitOptions = {}