Type Alias TSPrismaModels<T>

TSPrismaModels<T>: {
    ActiveInvite: {
        Aggregate: ActiveInviteAggregateArgs<T>;
        Count: ActiveInviteCountArgs<T>;
        Create: ActiveInviteCreateArgs<T>;
        CreateMany: ActiveInviteCreateManyArgs<T>;
        CreateManyAndReturn: ActiveInviteCreateManyAndReturnArgs<T>;
        Default: ActiveInviteDefaultArgs<T>;
        Delete: ActiveInviteDeleteArgs<T>;
        DeleteMany: ActiveInviteDeleteManyArgs<T>;
        FindFirst: ActiveInviteFindFirstArgs<T>;
        FindFirstOrThrow: ActiveInviteFindFirstOrThrowArgs<T>;
        FindMany: ActiveInviteFindManyArgs<T>;
        FindUnique: ActiveInviteFindUniqueArgs<T>;
        FindUniqueOrThrow: ActiveInviteFindUniqueOrThrowArgs<T>;
        GroupBy: ActiveInviteGroupByArgs<T>;
        Update: ActiveInviteUpdateArgs<T>;
        UpdateMany: ActiveInviteUpdateManyArgs<T>;
        UpdateManyAndReturn: ActiveInviteUpdateManyAndReturnArgs<T>;
        Upsert: ActiveInviteUpsertArgs<T>;
    };
    AllEnumsModel: {
        Aggregate: AllEnumsModelAggregateArgs<T>;
        Count: AllEnumsModelCountArgs<T>;
        Create: AllEnumsModelCreateArgs<T>;
        CreateMany: AllEnumsModelCreateManyArgs<T>;
        CreateManyAndReturn: AllEnumsModelCreateManyAndReturnArgs<T>;
        Default: AllEnumsModelDefaultArgs<T>;
        Delete: AllEnumsModelDeleteArgs<T>;
        DeleteMany: AllEnumsModelDeleteManyArgs<T>;
        FindFirst: AllEnumsModelFindFirstArgs<T>;
        FindFirstOrThrow: AllEnumsModelFindFirstOrThrowArgs<T>;
        FindMany: AllEnumsModelFindManyArgs<T>;
        FindUnique: AllEnumsModelFindUniqueArgs<T>;
        FindUniqueOrThrow: AllEnumsModelFindUniqueOrThrowArgs<T>;
        GroupBy: AllEnumsModelGroupByArgs<T>;
        Update: AllEnumsModelUpdateArgs<T>;
        UpdateMany: AllEnumsModelUpdateManyArgs<T>;
        UpdateManyAndReturn: AllEnumsModelUpdateManyAndReturnArgs<T>;
        Upsert: AllEnumsModelUpsertArgs<T>;
    };
    Client: {
        Aggregate: ClientAggregateArgs<T>;
        Count: ClientCountArgs<T>;
        Create: ClientCreateArgs<T>;
        CreateMany: ClientCreateManyArgs<T>;
        CreateManyAndReturn: ClientCreateManyAndReturnArgs<T>;
        Default: ClientDefaultArgs<T>;
        Delete: ClientDeleteArgs<T>;
        DeleteMany: ClientDeleteManyArgs<T>;
        FindFirst: ClientFindFirstArgs<T>;
        FindFirstOrThrow: ClientFindFirstOrThrowArgs<T>;
        FindMany: ClientFindManyArgs<T>;
        FindUnique: ClientFindUniqueArgs<T>;
        FindUniqueOrThrow: ClientFindUniqueOrThrowArgs<T>;
        GroupBy: ClientGroupByArgs<T>;
        Update: ClientUpdateArgs<T>;
        UpdateMany: ClientUpdateManyArgs<T>;
        UpdateManyAndReturn: ClientUpdateManyAndReturnArgs<T>;
        Upsert: ClientUpsertArgs<T>;
    };
    ClientBlog: {
        Aggregate: ClientBlogAggregateArgs<T>;
        Count: ClientBlogCountArgs<T>;
        Create: ClientBlogCreateArgs<T>;
        CreateMany: ClientBlogCreateManyArgs<T>;
        CreateManyAndReturn: ClientBlogCreateManyAndReturnArgs<T>;
        Default: ClientBlogDefaultArgs<T>;
        Delete: ClientBlogDeleteArgs<T>;
        DeleteMany: ClientBlogDeleteManyArgs<T>;
        FindFirst: ClientBlogFindFirstArgs<T>;
        FindFirstOrThrow: ClientBlogFindFirstOrThrowArgs<T>;
        FindMany: ClientBlogFindManyArgs<T>;
        FindUnique: ClientBlogFindUniqueArgs<T>;
        FindUniqueOrThrow: ClientBlogFindUniqueOrThrowArgs<T>;
        GroupBy: ClientBlogGroupByArgs<T>;
        Update: ClientBlogUpdateArgs<T>;
        UpdateMany: ClientBlogUpdateManyArgs<T>;
        UpdateManyAndReturn: ClientBlogUpdateManyAndReturnArgs<T>;
        Upsert: ClientBlogUpsertArgs<T>;
    };
    ClientChangelog: {
        Aggregate: ClientChangelogAggregateArgs<T>;
        Count: ClientChangelogCountArgs<T>;
        Create: ClientChangelogCreateArgs<T>;
        CreateMany: ClientChangelogCreateManyArgs<T>;
        CreateManyAndReturn: ClientChangelogCreateManyAndReturnArgs<T>;
        Default: ClientChangelogDefaultArgs<T>;
        Delete: ClientChangelogDeleteArgs<T>;
        DeleteMany: ClientChangelogDeleteManyArgs<T>;
        FindFirst: ClientChangelogFindFirstArgs<T>;
        FindFirstOrThrow: ClientChangelogFindFirstOrThrowArgs<T>;
        FindMany: ClientChangelogFindManyArgs<T>;
        FindUnique: ClientChangelogFindUniqueArgs<T>;
        FindUniqueOrThrow: ClientChangelogFindUniqueOrThrowArgs<T>;
        GroupBy: ClientChangelogGroupByArgs<T>;
        Update: ClientChangelogUpdateArgs<T>;
        UpdateMany: ClientChangelogUpdateManyArgs<T>;
        UpdateManyAndReturn: ClientChangelogUpdateManyAndReturnArgs<T>;
        Upsert: ClientChangelogUpsertArgs<T>;
    };
    ClientFAQ: {
        Aggregate: ClientFAQAggregateArgs<T>;
        Count: ClientFAQCountArgs<T>;
        Create: ClientFAQCreateArgs<T>;
        CreateMany: ClientFAQCreateManyArgs<T>;
        CreateManyAndReturn: ClientFAQCreateManyAndReturnArgs<T>;
        Default: ClientFAQDefaultArgs<T>;
        Delete: ClientFAQDeleteArgs<T>;
        DeleteMany: ClientFAQDeleteManyArgs<T>;
        FindFirst: ClientFAQFindFirstArgs<T>;
        FindFirstOrThrow: ClientFAQFindFirstOrThrowArgs<T>;
        FindMany: ClientFAQFindManyArgs<T>;
        FindUnique: ClientFAQFindUniqueArgs<T>;
        FindUniqueOrThrow: ClientFAQFindUniqueOrThrowArgs<T>;
        GroupBy: ClientFAQGroupByArgs<T>;
        Update: ClientFAQUpdateArgs<T>;
        UpdateMany: ClientFAQUpdateManyArgs<T>;
        UpdateManyAndReturn: ClientFAQUpdateManyAndReturnArgs<T>;
        Upsert: ClientFAQUpsertArgs<T>;
    };
    ClientLogRawData: {
        Aggregate: ClientLogRawDataAggregateArgs<T>;
        Count: ClientLogRawDataCountArgs<T>;
        Create: ClientLogRawDataCreateArgs<T>;
        CreateMany: ClientLogRawDataCreateManyArgs<T>;
        CreateManyAndReturn: ClientLogRawDataCreateManyAndReturnArgs<T>;
        Default: ClientLogRawDataDefaultArgs<T>;
        Delete: ClientLogRawDataDeleteArgs<T>;
        DeleteMany: ClientLogRawDataDeleteManyArgs<T>;
        FindFirst: ClientLogRawDataFindFirstArgs<T>;
        FindFirstOrThrow: ClientLogRawDataFindFirstOrThrowArgs<T>;
        FindMany: ClientLogRawDataFindManyArgs<T>;
        FindUnique: ClientLogRawDataFindUniqueArgs<T>;
        FindUniqueOrThrow: ClientLogRawDataFindUniqueOrThrowArgs<T>;
        GroupBy: ClientLogRawDataGroupByArgs<T>;
        Update: ClientLogRawDataUpdateArgs<T>;
        UpdateMany: ClientLogRawDataUpdateManyArgs<T>;
        UpdateManyAndReturn: ClientLogRawDataUpdateManyAndReturnArgs<T>;
        Upsert: ClientLogRawDataUpsertArgs<T>;
    };
    Drop: {
        Aggregate: DropAggregateArgs<T>;
        Count: DropCountArgs<T>;
        Create: DropCreateArgs<T>;
        CreateMany: DropCreateManyArgs<T>;
        CreateManyAndReturn: DropCreateManyAndReturnArgs<T>;
        Default: DropDefaultArgs<T>;
        Delete: DropDeleteArgs<T>;
        DeleteMany: DropDeleteManyArgs<T>;
        FindFirst: DropFindFirstArgs<T>;
        FindFirstOrThrow: DropFindFirstOrThrowArgs<T>;
        FindMany: DropFindManyArgs<T>;
        FindUnique: DropFindUniqueArgs<T>;
        FindUniqueOrThrow: DropFindUniqueOrThrowArgs<T>;
        GroupBy: DropGroupByArgs<T>;
        Update: DropUpdateArgs<T>;
        UpdateMany: DropUpdateManyArgs<T>;
        UpdateManyAndReturn: DropUpdateManyAndReturnArgs<T>;
        Upsert: DropUpsertArgs<T>;
    };
    DropGame: {
        Aggregate: DropGameAggregateArgs<T>;
        Count: DropGameCountArgs<T>;
        Create: DropGameCreateArgs<T>;
        CreateMany: DropGameCreateManyArgs<T>;
        CreateManyAndReturn: DropGameCreateManyAndReturnArgs<T>;
        Default: DropGameDefaultArgs<T>;
        Delete: DropGameDeleteArgs<T>;
        DeleteMany: DropGameDeleteManyArgs<T>;
        FindFirst: DropGameFindFirstArgs<T>;
        FindFirstOrThrow: DropGameFindFirstOrThrowArgs<T>;
        FindMany: DropGameFindManyArgs<T>;
        FindUnique: DropGameFindUniqueArgs<T>;
        FindUniqueOrThrow: DropGameFindUniqueOrThrowArgs<T>;
        GroupBy: DropGameGroupByArgs<T>;
        Update: DropGameUpdateArgs<T>;
        UpdateMany: DropGameUpdateManyArgs<T>;
        UpdateManyAndReturn: DropGameUpdateManyAndReturnArgs<T>;
        Upsert: DropGameUpsertArgs<T>;
    };
    Guild: {
        Aggregate: GuildAggregateArgs<T>;
        Count: GuildCountArgs<T>;
        Create: GuildCreateArgs<T>;
        CreateMany: GuildCreateManyArgs<T>;
        CreateManyAndReturn: GuildCreateManyAndReturnArgs<T>;
        Default: GuildDefaultArgs<T>;
        Delete: GuildDeleteArgs<T>;
        DeleteMany: GuildDeleteManyArgs<T>;
        FindFirst: GuildFindFirstArgs<T>;
        FindFirstOrThrow: GuildFindFirstOrThrowArgs<T>;
        FindMany: GuildFindManyArgs<T>;
        FindUnique: GuildFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGroupByArgs<T>;
        Update: GuildUpdateArgs<T>;
        UpdateMany: GuildUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildUpdateManyAndReturnArgs<T>;
        Upsert: GuildUpsertArgs<T>;
    };
    GuildAutoLiveRole: {
        Aggregate: GuildAutoLiveRoleAggregateArgs<T>;
        Count: GuildAutoLiveRoleCountArgs<T>;
        Create: GuildAutoLiveRoleCreateArgs<T>;
        CreateMany: GuildAutoLiveRoleCreateManyArgs<T>;
        CreateManyAndReturn: GuildAutoLiveRoleCreateManyAndReturnArgs<T>;
        Default: GuildAutoLiveRoleDefaultArgs<T>;
        Delete: GuildAutoLiveRoleDeleteArgs<T>;
        DeleteMany: GuildAutoLiveRoleDeleteManyArgs<T>;
        FindFirst: GuildAutoLiveRoleFindFirstArgs<T>;
        FindFirstOrThrow: GuildAutoLiveRoleFindFirstOrThrowArgs<T>;
        FindMany: GuildAutoLiveRoleFindManyArgs<T>;
        FindUnique: GuildAutoLiveRoleFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildAutoLiveRoleFindUniqueOrThrowArgs<T>;
        GroupBy: GuildAutoLiveRoleGroupByArgs<T>;
        Update: GuildAutoLiveRoleUpdateArgs<T>;
        UpdateMany: GuildAutoLiveRoleUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildAutoLiveRoleUpdateManyAndReturnArgs<T>;
        Upsert: GuildAutoLiveRoleUpsertArgs<T>;
    };
    GuildAutoLiveRoleFilter: {
        Aggregate: GuildAutoLiveRoleFilterAggregateArgs<T>;
        Count: GuildAutoLiveRoleFilterCountArgs<T>;
        Create: GuildAutoLiveRoleFilterCreateArgs<T>;
        CreateMany: GuildAutoLiveRoleFilterCreateManyArgs<T>;
        CreateManyAndReturn: GuildAutoLiveRoleFilterCreateManyAndReturnArgs<T>;
        Default: GuildAutoLiveRoleFilterDefaultArgs<T>;
        Delete: GuildAutoLiveRoleFilterDeleteArgs<T>;
        DeleteMany: GuildAutoLiveRoleFilterDeleteManyArgs<T>;
        FindFirst: GuildAutoLiveRoleFilterFindFirstArgs<T>;
        FindFirstOrThrow: GuildAutoLiveRoleFilterFindFirstOrThrowArgs<T>;
        FindMany: GuildAutoLiveRoleFilterFindManyArgs<T>;
        FindUnique: GuildAutoLiveRoleFilterFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildAutoLiveRoleFilterFindUniqueOrThrowArgs<T>;
        GroupBy: GuildAutoLiveRoleFilterGroupByArgs<T>;
        Update: GuildAutoLiveRoleFilterUpdateArgs<T>;
        UpdateMany: GuildAutoLiveRoleFilterUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildAutoLiveRoleFilterUpdateManyAndReturnArgs<T>;
        Upsert: GuildAutoLiveRoleFilterUpsertArgs<T>;
    };
    GuildCustomMessage: {
        Aggregate: GuildCustomMessageAggregateArgs<T>;
        Count: GuildCustomMessageCountArgs<T>;
        Create: GuildCustomMessageCreateArgs<T>;
        CreateMany: GuildCustomMessageCreateManyArgs<T>;
        CreateManyAndReturn: GuildCustomMessageCreateManyAndReturnArgs<T>;
        Default: GuildCustomMessageDefaultArgs<T>;
        Delete: GuildCustomMessageDeleteArgs<T>;
        DeleteMany: GuildCustomMessageDeleteManyArgs<T>;
        FindFirst: GuildCustomMessageFindFirstArgs<T>;
        FindFirstOrThrow: GuildCustomMessageFindFirstOrThrowArgs<T>;
        FindMany: GuildCustomMessageFindManyArgs<T>;
        FindUnique: GuildCustomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildCustomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: GuildCustomMessageGroupByArgs<T>;
        Update: GuildCustomMessageUpdateArgs<T>;
        UpdateMany: GuildCustomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildCustomMessageUpdateManyAndReturnArgs<T>;
        Upsert: GuildCustomMessageUpsertArgs<T>;
    };
    GuildCustomSingleMessage: {
        Aggregate: GuildCustomSingleMessageAggregateArgs<T>;
        Count: GuildCustomSingleMessageCountArgs<T>;
        Create: GuildCustomSingleMessageCreateArgs<T>;
        CreateMany: GuildCustomSingleMessageCreateManyArgs<T>;
        CreateManyAndReturn: GuildCustomSingleMessageCreateManyAndReturnArgs<T>;
        Default: GuildCustomSingleMessageDefaultArgs<T>;
        Delete: GuildCustomSingleMessageDeleteArgs<T>;
        DeleteMany: GuildCustomSingleMessageDeleteManyArgs<T>;
        FindFirst: GuildCustomSingleMessageFindFirstArgs<T>;
        FindFirstOrThrow: GuildCustomSingleMessageFindFirstOrThrowArgs<T>;
        FindMany: GuildCustomSingleMessageFindManyArgs<T>;
        FindUnique: GuildCustomSingleMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildCustomSingleMessageFindUniqueOrThrowArgs<T>;
        GroupBy: GuildCustomSingleMessageGroupByArgs<T>;
        Update: GuildCustomSingleMessageUpdateArgs<T>;
        UpdateMany: GuildCustomSingleMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildCustomSingleMessageUpdateManyAndReturnArgs<T>;
        Upsert: GuildCustomSingleMessageUpsertArgs<T>;
    };
    GuildDisableBranding: {
        Aggregate: GuildDisableBrandingAggregateArgs<T>;
        Count: GuildDisableBrandingCountArgs<T>;
        Create: GuildDisableBrandingCreateArgs<T>;
        CreateMany: GuildDisableBrandingCreateManyArgs<T>;
        CreateManyAndReturn: GuildDisableBrandingCreateManyAndReturnArgs<T>;
        Default: GuildDisableBrandingDefaultArgs<T>;
        Delete: GuildDisableBrandingDeleteArgs<T>;
        DeleteMany: GuildDisableBrandingDeleteManyArgs<T>;
        FindFirst: GuildDisableBrandingFindFirstArgs<T>;
        FindFirstOrThrow: GuildDisableBrandingFindFirstOrThrowArgs<T>;
        FindMany: GuildDisableBrandingFindManyArgs<T>;
        FindUnique: GuildDisableBrandingFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildDisableBrandingFindUniqueOrThrowArgs<T>;
        GroupBy: GuildDisableBrandingGroupByArgs<T>;
        Update: GuildDisableBrandingUpdateArgs<T>;
        UpdateMany: GuildDisableBrandingUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildDisableBrandingUpdateManyAndReturnArgs<T>;
        Upsert: GuildDisableBrandingUpsertArgs<T>;
    };
    GuildDrops: {
        Aggregate: GuildDropsAggregateArgs<T>;
        Count: GuildDropsCountArgs<T>;
        Create: GuildDropsCreateArgs<T>;
        CreateMany: GuildDropsCreateManyArgs<T>;
        CreateManyAndReturn: GuildDropsCreateManyAndReturnArgs<T>;
        Default: GuildDropsDefaultArgs<T>;
        Delete: GuildDropsDeleteArgs<T>;
        DeleteMany: GuildDropsDeleteManyArgs<T>;
        FindFirst: GuildDropsFindFirstArgs<T>;
        FindFirstOrThrow: GuildDropsFindFirstOrThrowArgs<T>;
        FindMany: GuildDropsFindManyArgs<T>;
        FindUnique: GuildDropsFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildDropsFindUniqueOrThrowArgs<T>;
        GroupBy: GuildDropsGroupByArgs<T>;
        Update: GuildDropsUpdateArgs<T>;
        UpdateMany: GuildDropsUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildDropsUpdateManyAndReturnArgs<T>;
        Upsert: GuildDropsUpsertArgs<T>;
    };
    GuildDropsGame: {
        Aggregate: GuildDropsGameAggregateArgs<T>;
        Count: GuildDropsGameCountArgs<T>;
        Create: GuildDropsGameCreateArgs<T>;
        CreateMany: GuildDropsGameCreateManyArgs<T>;
        CreateManyAndReturn: GuildDropsGameCreateManyAndReturnArgs<T>;
        Default: GuildDropsGameDefaultArgs<T>;
        Delete: GuildDropsGameDeleteArgs<T>;
        DeleteMany: GuildDropsGameDeleteManyArgs<T>;
        FindFirst: GuildDropsGameFindFirstArgs<T>;
        FindFirstOrThrow: GuildDropsGameFindFirstOrThrowArgs<T>;
        FindMany: GuildDropsGameFindManyArgs<T>;
        FindUnique: GuildDropsGameFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildDropsGameFindUniqueOrThrowArgs<T>;
        GroupBy: GuildDropsGameGroupByArgs<T>;
        Update: GuildDropsGameUpdateArgs<T>;
        UpdateMany: GuildDropsGameUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildDropsGameUpdateManyAndReturnArgs<T>;
        Upsert: GuildDropsGameUpsertArgs<T>;
    };
    GuildDropsGameWebhook: {
        Aggregate: GuildDropsGameWebhookAggregateArgs<T>;
        Count: GuildDropsGameWebhookCountArgs<T>;
        Create: GuildDropsGameWebhookCreateArgs<T>;
        CreateMany: GuildDropsGameWebhookCreateManyArgs<T>;
        CreateManyAndReturn: GuildDropsGameWebhookCreateManyAndReturnArgs<T>;
        Default: GuildDropsGameWebhookDefaultArgs<T>;
        Delete: GuildDropsGameWebhookDeleteArgs<T>;
        DeleteMany: GuildDropsGameWebhookDeleteManyArgs<T>;
        FindFirst: GuildDropsGameWebhookFindFirstArgs<T>;
        FindFirstOrThrow: GuildDropsGameWebhookFindFirstOrThrowArgs<T>;
        FindMany: GuildDropsGameWebhookFindManyArgs<T>;
        FindUnique: GuildDropsGameWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildDropsGameWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: GuildDropsGameWebhookGroupByArgs<T>;
        Update: GuildDropsGameWebhookUpdateArgs<T>;
        UpdateMany: GuildDropsGameWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildDropsGameWebhookUpdateManyAndReturnArgs<T>;
        Upsert: GuildDropsGameWebhookUpsertArgs<T>;
    };
    GuildDropsWebhook: {
        Aggregate: GuildDropsWebhookAggregateArgs<T>;
        Count: GuildDropsWebhookCountArgs<T>;
        Create: GuildDropsWebhookCreateArgs<T>;
        CreateMany: GuildDropsWebhookCreateManyArgs<T>;
        CreateManyAndReturn: GuildDropsWebhookCreateManyAndReturnArgs<T>;
        Default: GuildDropsWebhookDefaultArgs<T>;
        Delete: GuildDropsWebhookDeleteArgs<T>;
        DeleteMany: GuildDropsWebhookDeleteManyArgs<T>;
        FindFirst: GuildDropsWebhookFindFirstArgs<T>;
        FindFirstOrThrow: GuildDropsWebhookFindFirstOrThrowArgs<T>;
        FindMany: GuildDropsWebhookFindManyArgs<T>;
        FindUnique: GuildDropsWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildDropsWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: GuildDropsWebhookGroupByArgs<T>;
        Update: GuildDropsWebhookUpdateArgs<T>;
        UpdateMany: GuildDropsWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildDropsWebhookUpdateManyAndReturnArgs<T>;
        Upsert: GuildDropsWebhookUpsertArgs<T>;
    };
    GuildEmbedField: {
        Aggregate: GuildEmbedFieldAggregateArgs<T>;
        Count: GuildEmbedFieldCountArgs<T>;
        Create: GuildEmbedFieldCreateArgs<T>;
        CreateMany: GuildEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: GuildEmbedFieldCreateManyAndReturnArgs<T>;
        Default: GuildEmbedFieldDefaultArgs<T>;
        Delete: GuildEmbedFieldDeleteArgs<T>;
        DeleteMany: GuildEmbedFieldDeleteManyArgs<T>;
        FindFirst: GuildEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: GuildEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: GuildEmbedFieldFindManyArgs<T>;
        FindUnique: GuildEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: GuildEmbedFieldGroupByArgs<T>;
        Update: GuildEmbedFieldUpdateArgs<T>;
        UpdateMany: GuildEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: GuildEmbedFieldUpsertArgs<T>;
    };
    GuildGettingStarted: {
        Aggregate: GuildGettingStartedAggregateArgs<T>;
        Count: GuildGettingStartedCountArgs<T>;
        Create: GuildGettingStartedCreateArgs<T>;
        CreateMany: GuildGettingStartedCreateManyArgs<T>;
        CreateManyAndReturn: GuildGettingStartedCreateManyAndReturnArgs<T>;
        Default: GuildGettingStartedDefaultArgs<T>;
        Delete: GuildGettingStartedDeleteArgs<T>;
        DeleteMany: GuildGettingStartedDeleteManyArgs<T>;
        FindFirst: GuildGettingStartedFindFirstArgs<T>;
        FindFirstOrThrow: GuildGettingStartedFindFirstOrThrowArgs<T>;
        FindMany: GuildGettingStartedFindManyArgs<T>;
        FindUnique: GuildGettingStartedFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildGettingStartedFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGettingStartedGroupByArgs<T>;
        Update: GuildGettingStartedUpdateArgs<T>;
        UpdateMany: GuildGettingStartedUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildGettingStartedUpdateManyAndReturnArgs<T>;
        Upsert: GuildGettingStartedUpsertArgs<T>;
    };
    GuildGiveaway: {
        Aggregate: GuildGiveawayAggregateArgs<T>;
        Count: GuildGiveawayCountArgs<T>;
        Create: GuildGiveawayCreateArgs<T>;
        CreateMany: GuildGiveawayCreateManyArgs<T>;
        CreateManyAndReturn: GuildGiveawayCreateManyAndReturnArgs<T>;
        Default: GuildGiveawayDefaultArgs<T>;
        Delete: GuildGiveawayDeleteArgs<T>;
        DeleteMany: GuildGiveawayDeleteManyArgs<T>;
        FindFirst: GuildGiveawayFindFirstArgs<T>;
        FindFirstOrThrow: GuildGiveawayFindFirstOrThrowArgs<T>;
        FindMany: GuildGiveawayFindManyArgs<T>;
        FindUnique: GuildGiveawayFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildGiveawayFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGiveawayGroupByArgs<T>;
        Update: GuildGiveawayUpdateArgs<T>;
        UpdateMany: GuildGiveawayUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildGiveawayUpdateManyAndReturnArgs<T>;
        Upsert: GuildGiveawayUpsertArgs<T>;
    };
    GuildGiveawayEntry: {
        Aggregate: GuildGiveawayEntryAggregateArgs<T>;
        Count: GuildGiveawayEntryCountArgs<T>;
        Create: GuildGiveawayEntryCreateArgs<T>;
        CreateMany: GuildGiveawayEntryCreateManyArgs<T>;
        CreateManyAndReturn: GuildGiveawayEntryCreateManyAndReturnArgs<T>;
        Default: GuildGiveawayEntryDefaultArgs<T>;
        Delete: GuildGiveawayEntryDeleteArgs<T>;
        DeleteMany: GuildGiveawayEntryDeleteManyArgs<T>;
        FindFirst: GuildGiveawayEntryFindFirstArgs<T>;
        FindFirstOrThrow: GuildGiveawayEntryFindFirstOrThrowArgs<T>;
        FindMany: GuildGiveawayEntryFindManyArgs<T>;
        FindUnique: GuildGiveawayEntryFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildGiveawayEntryFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGiveawayEntryGroupByArgs<T>;
        Update: GuildGiveawayEntryUpdateArgs<T>;
        UpdateMany: GuildGiveawayEntryUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildGiveawayEntryUpdateManyAndReturnArgs<T>;
        Upsert: GuildGiveawayEntryUpsertArgs<T>;
    };
    GuildGiveawayFilter: {
        Aggregate: GuildGiveawayFilterAggregateArgs<T>;
        Count: GuildGiveawayFilterCountArgs<T>;
        Create: GuildGiveawayFilterCreateArgs<T>;
        CreateMany: GuildGiveawayFilterCreateManyArgs<T>;
        CreateManyAndReturn: GuildGiveawayFilterCreateManyAndReturnArgs<T>;
        Default: GuildGiveawayFilterDefaultArgs<T>;
        Delete: GuildGiveawayFilterDeleteArgs<T>;
        DeleteMany: GuildGiveawayFilterDeleteManyArgs<T>;
        FindFirst: GuildGiveawayFilterFindFirstArgs<T>;
        FindFirstOrThrow: GuildGiveawayFilterFindFirstOrThrowArgs<T>;
        FindMany: GuildGiveawayFilterFindManyArgs<T>;
        FindUnique: GuildGiveawayFilterFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildGiveawayFilterFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGiveawayFilterGroupByArgs<T>;
        Update: GuildGiveawayFilterUpdateArgs<T>;
        UpdateMany: GuildGiveawayFilterUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildGiveawayFilterUpdateManyAndReturnArgs<T>;
        Upsert: GuildGiveawayFilterUpsertArgs<T>;
    };
    GuildGiveawayRequirements: {
        Aggregate: GuildGiveawayRequirementsAggregateArgs<T>;
        Count: GuildGiveawayRequirementsCountArgs<T>;
        Create: GuildGiveawayRequirementsCreateArgs<T>;
        CreateMany: GuildGiveawayRequirementsCreateManyArgs<T>;
        CreateManyAndReturn: GuildGiveawayRequirementsCreateManyAndReturnArgs<T>;
        Default: GuildGiveawayRequirementsDefaultArgs<T>;
        Delete: GuildGiveawayRequirementsDeleteArgs<T>;
        DeleteMany: GuildGiveawayRequirementsDeleteManyArgs<T>;
        FindFirst: GuildGiveawayRequirementsFindFirstArgs<T>;
        FindFirstOrThrow: GuildGiveawayRequirementsFindFirstOrThrowArgs<T>;
        FindMany: GuildGiveawayRequirementsFindManyArgs<T>;
        FindUnique: GuildGiveawayRequirementsFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildGiveawayRequirementsFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGiveawayRequirementsGroupByArgs<T>;
        Update: GuildGiveawayRequirementsUpdateArgs<T>;
        UpdateMany: GuildGiveawayRequirementsUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildGiveawayRequirementsUpdateManyAndReturnArgs<T>;
        Upsert: GuildGiveawayRequirementsUpsertArgs<T>;
    };
    GuildGiveawayRoleBonus: {
        Aggregate: GuildGiveawayRoleBonusAggregateArgs<T>;
        Count: GuildGiveawayRoleBonusCountArgs<T>;
        Create: GuildGiveawayRoleBonusCreateArgs<T>;
        CreateMany: GuildGiveawayRoleBonusCreateManyArgs<T>;
        CreateManyAndReturn: GuildGiveawayRoleBonusCreateManyAndReturnArgs<T>;
        Default: GuildGiveawayRoleBonusDefaultArgs<T>;
        Delete: GuildGiveawayRoleBonusDeleteArgs<T>;
        DeleteMany: GuildGiveawayRoleBonusDeleteManyArgs<T>;
        FindFirst: GuildGiveawayRoleBonusFindFirstArgs<T>;
        FindFirstOrThrow: GuildGiveawayRoleBonusFindFirstOrThrowArgs<T>;
        FindMany: GuildGiveawayRoleBonusFindManyArgs<T>;
        FindUnique: GuildGiveawayRoleBonusFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildGiveawayRoleBonusFindUniqueOrThrowArgs<T>;
        GroupBy: GuildGiveawayRoleBonusGroupByArgs<T>;
        Update: GuildGiveawayRoleBonusUpdateArgs<T>;
        UpdateMany: GuildGiveawayRoleBonusUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildGiveawayRoleBonusUpdateManyAndReturnArgs<T>;
        Upsert: GuildGiveawayRoleBonusUpsertArgs<T>;
    };
    GuildLinkedRole: {
        Aggregate: GuildLinkedRoleAggregateArgs<T>;
        Count: GuildLinkedRoleCountArgs<T>;
        Create: GuildLinkedRoleCreateArgs<T>;
        CreateMany: GuildLinkedRoleCreateManyArgs<T>;
        CreateManyAndReturn: GuildLinkedRoleCreateManyAndReturnArgs<T>;
        Default: GuildLinkedRoleDefaultArgs<T>;
        Delete: GuildLinkedRoleDeleteArgs<T>;
        DeleteMany: GuildLinkedRoleDeleteManyArgs<T>;
        FindFirst: GuildLinkedRoleFindFirstArgs<T>;
        FindFirstOrThrow: GuildLinkedRoleFindFirstOrThrowArgs<T>;
        FindMany: GuildLinkedRoleFindManyArgs<T>;
        FindUnique: GuildLinkedRoleFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildLinkedRoleFindUniqueOrThrowArgs<T>;
        GroupBy: GuildLinkedRoleGroupByArgs<T>;
        Update: GuildLinkedRoleUpdateArgs<T>;
        UpdateMany: GuildLinkedRoleUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildLinkedRoleUpdateManyAndReturnArgs<T>;
        Upsert: GuildLinkedRoleUpsertArgs<T>;
    };
    GuildMessageButton: {
        Aggregate: GuildMessageButtonAggregateArgs<T>;
        Count: GuildMessageButtonCountArgs<T>;
        Create: GuildMessageButtonCreateArgs<T>;
        CreateMany: GuildMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: GuildMessageButtonCreateManyAndReturnArgs<T>;
        Default: GuildMessageButtonDefaultArgs<T>;
        Delete: GuildMessageButtonDeleteArgs<T>;
        DeleteMany: GuildMessageButtonDeleteManyArgs<T>;
        FindFirst: GuildMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: GuildMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: GuildMessageButtonFindManyArgs<T>;
        FindUnique: GuildMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: GuildMessageButtonGroupByArgs<T>;
        Update: GuildMessageButtonUpdateArgs<T>;
        UpdateMany: GuildMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: GuildMessageButtonUpsertArgs<T>;
    };
    GuildMessageEmbed: {
        Aggregate: GuildMessageEmbedAggregateArgs<T>;
        Count: GuildMessageEmbedCountArgs<T>;
        Create: GuildMessageEmbedCreateArgs<T>;
        CreateMany: GuildMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: GuildMessageEmbedCreateManyAndReturnArgs<T>;
        Default: GuildMessageEmbedDefaultArgs<T>;
        Delete: GuildMessageEmbedDeleteArgs<T>;
        DeleteMany: GuildMessageEmbedDeleteManyArgs<T>;
        FindFirst: GuildMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: GuildMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: GuildMessageEmbedFindManyArgs<T>;
        FindUnique: GuildMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: GuildMessageEmbedGroupByArgs<T>;
        Update: GuildMessageEmbedUpdateArgs<T>;
        UpdateMany: GuildMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: GuildMessageEmbedUpsertArgs<T>;
    };
    GuildMessageWebhook: {
        Aggregate: GuildMessageWebhookAggregateArgs<T>;
        Count: GuildMessageWebhookCountArgs<T>;
        Create: GuildMessageWebhookCreateArgs<T>;
        CreateMany: GuildMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: GuildMessageWebhookCreateManyAndReturnArgs<T>;
        Default: GuildMessageWebhookDefaultArgs<T>;
        Delete: GuildMessageWebhookDeleteArgs<T>;
        DeleteMany: GuildMessageWebhookDeleteManyArgs<T>;
        FindFirst: GuildMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: GuildMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: GuildMessageWebhookFindManyArgs<T>;
        FindUnique: GuildMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: GuildMessageWebhookGroupByArgs<T>;
        Update: GuildMessageWebhookUpdateArgs<T>;
        UpdateMany: GuildMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: GuildMessageWebhookUpsertArgs<T>;
    };
    GuildNotificationOverride: {
        Aggregate: GuildNotificationOverrideAggregateArgs<T>;
        Count: GuildNotificationOverrideCountArgs<T>;
        Create: GuildNotificationOverrideCreateArgs<T>;
        CreateMany: GuildNotificationOverrideCreateManyArgs<T>;
        CreateManyAndReturn: GuildNotificationOverrideCreateManyAndReturnArgs<T>;
        Default: GuildNotificationOverrideDefaultArgs<T>;
        Delete: GuildNotificationOverrideDeleteArgs<T>;
        DeleteMany: GuildNotificationOverrideDeleteManyArgs<T>;
        FindFirst: GuildNotificationOverrideFindFirstArgs<T>;
        FindFirstOrThrow: GuildNotificationOverrideFindFirstOrThrowArgs<T>;
        FindMany: GuildNotificationOverrideFindManyArgs<T>;
        FindUnique: GuildNotificationOverrideFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildNotificationOverrideFindUniqueOrThrowArgs<T>;
        GroupBy: GuildNotificationOverrideGroupByArgs<T>;
        Update: GuildNotificationOverrideUpdateArgs<T>;
        UpdateMany: GuildNotificationOverrideUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildNotificationOverrideUpdateManyAndReturnArgs<T>;
        Upsert: GuildNotificationOverrideUpsertArgs<T>;
    };
    GuildPremium: {
        Aggregate: GuildPremiumAggregateArgs<T>;
        Count: GuildPremiumCountArgs<T>;
        Create: GuildPremiumCreateArgs<T>;
        CreateMany: GuildPremiumCreateManyArgs<T>;
        CreateManyAndReturn: GuildPremiumCreateManyAndReturnArgs<T>;
        Default: GuildPremiumDefaultArgs<T>;
        Delete: GuildPremiumDeleteArgs<T>;
        DeleteMany: GuildPremiumDeleteManyArgs<T>;
        FindFirst: GuildPremiumFindFirstArgs<T>;
        FindFirstOrThrow: GuildPremiumFindFirstOrThrowArgs<T>;
        FindMany: GuildPremiumFindManyArgs<T>;
        FindUnique: GuildPremiumFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildPremiumFindUniqueOrThrowArgs<T>;
        GroupBy: GuildPremiumGroupByArgs<T>;
        Update: GuildPremiumUpdateArgs<T>;
        UpdateMany: GuildPremiumUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildPremiumUpdateManyAndReturnArgs<T>;
        Upsert: GuildPremiumUpsertArgs<T>;
    };
    GuildRandomMessage: {
        Aggregate: GuildRandomMessageAggregateArgs<T>;
        Count: GuildRandomMessageCountArgs<T>;
        Create: GuildRandomMessageCreateArgs<T>;
        CreateMany: GuildRandomMessageCreateManyArgs<T>;
        CreateManyAndReturn: GuildRandomMessageCreateManyAndReturnArgs<T>;
        Default: GuildRandomMessageDefaultArgs<T>;
        Delete: GuildRandomMessageDeleteArgs<T>;
        DeleteMany: GuildRandomMessageDeleteManyArgs<T>;
        FindFirst: GuildRandomMessageFindFirstArgs<T>;
        FindFirstOrThrow: GuildRandomMessageFindFirstOrThrowArgs<T>;
        FindMany: GuildRandomMessageFindManyArgs<T>;
        FindUnique: GuildRandomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildRandomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: GuildRandomMessageGroupByArgs<T>;
        Update: GuildRandomMessageUpdateArgs<T>;
        UpdateMany: GuildRandomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildRandomMessageUpdateManyAndReturnArgs<T>;
        Upsert: GuildRandomMessageUpsertArgs<T>;
    };
    GuildSingleMessageWebhook: {
        Aggregate: GuildSingleMessageWebhookAggregateArgs<T>;
        Count: GuildSingleMessageWebhookCountArgs<T>;
        Create: GuildSingleMessageWebhookCreateArgs<T>;
        CreateMany: GuildSingleMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: GuildSingleMessageWebhookCreateManyAndReturnArgs<T>;
        Default: GuildSingleMessageWebhookDefaultArgs<T>;
        Delete: GuildSingleMessageWebhookDeleteArgs<T>;
        DeleteMany: GuildSingleMessageWebhookDeleteManyArgs<T>;
        FindFirst: GuildSingleMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: GuildSingleMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: GuildSingleMessageWebhookFindManyArgs<T>;
        FindUnique: GuildSingleMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildSingleMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: GuildSingleMessageWebhookGroupByArgs<T>;
        Update: GuildSingleMessageWebhookUpdateArgs<T>;
        UpdateMany: GuildSingleMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildSingleMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: GuildSingleMessageWebhookUpsertArgs<T>;
    };
    GuildStarboard: {
        Aggregate: GuildStarboardAggregateArgs<T>;
        Count: GuildStarboardCountArgs<T>;
        Create: GuildStarboardCreateArgs<T>;
        CreateMany: GuildStarboardCreateManyArgs<T>;
        CreateManyAndReturn: GuildStarboardCreateManyAndReturnArgs<T>;
        Default: GuildStarboardDefaultArgs<T>;
        Delete: GuildStarboardDeleteArgs<T>;
        DeleteMany: GuildStarboardDeleteManyArgs<T>;
        FindFirst: GuildStarboardFindFirstArgs<T>;
        FindFirstOrThrow: GuildStarboardFindFirstOrThrowArgs<T>;
        FindMany: GuildStarboardFindManyArgs<T>;
        FindUnique: GuildStarboardFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStarboardFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStarboardGroupByArgs<T>;
        Update: GuildStarboardUpdateArgs<T>;
        UpdateMany: GuildStarboardUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStarboardUpdateManyAndReturnArgs<T>;
        Upsert: GuildStarboardUpsertArgs<T>;
    };
    GuildStarboardFilter: {
        Aggregate: GuildStarboardFilterAggregateArgs<T>;
        Count: GuildStarboardFilterCountArgs<T>;
        Create: GuildStarboardFilterCreateArgs<T>;
        CreateMany: GuildStarboardFilterCreateManyArgs<T>;
        CreateManyAndReturn: GuildStarboardFilterCreateManyAndReturnArgs<T>;
        Default: GuildStarboardFilterDefaultArgs<T>;
        Delete: GuildStarboardFilterDeleteArgs<T>;
        DeleteMany: GuildStarboardFilterDeleteManyArgs<T>;
        FindFirst: GuildStarboardFilterFindFirstArgs<T>;
        FindFirstOrThrow: GuildStarboardFilterFindFirstOrThrowArgs<T>;
        FindMany: GuildStarboardFilterFindManyArgs<T>;
        FindUnique: GuildStarboardFilterFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStarboardFilterFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStarboardFilterGroupByArgs<T>;
        Update: GuildStarboardFilterUpdateArgs<T>;
        UpdateMany: GuildStarboardFilterUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStarboardFilterUpdateManyAndReturnArgs<T>;
        Upsert: GuildStarboardFilterUpsertArgs<T>;
    };
    GuildStarboardMessage: {
        Aggregate: GuildStarboardMessageAggregateArgs<T>;
        Count: GuildStarboardMessageCountArgs<T>;
        Create: GuildStarboardMessageCreateArgs<T>;
        CreateMany: GuildStarboardMessageCreateManyArgs<T>;
        CreateManyAndReturn: GuildStarboardMessageCreateManyAndReturnArgs<T>;
        Default: GuildStarboardMessageDefaultArgs<T>;
        Delete: GuildStarboardMessageDeleteArgs<T>;
        DeleteMany: GuildStarboardMessageDeleteManyArgs<T>;
        FindFirst: GuildStarboardMessageFindFirstArgs<T>;
        FindFirstOrThrow: GuildStarboardMessageFindFirstOrThrowArgs<T>;
        FindMany: GuildStarboardMessageFindManyArgs<T>;
        FindUnique: GuildStarboardMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStarboardMessageFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStarboardMessageGroupByArgs<T>;
        Update: GuildStarboardMessageUpdateArgs<T>;
        UpdateMany: GuildStarboardMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStarboardMessageUpdateManyAndReturnArgs<T>;
        Upsert: GuildStarboardMessageUpsertArgs<T>;
    };
    GuildStarboardMessages: {
        Aggregate: GuildStarboardMessagesAggregateArgs<T>;
        Count: GuildStarboardMessagesCountArgs<T>;
        Create: GuildStarboardMessagesCreateArgs<T>;
        CreateMany: GuildStarboardMessagesCreateManyArgs<T>;
        CreateManyAndReturn: GuildStarboardMessagesCreateManyAndReturnArgs<T>;
        Default: GuildStarboardMessagesDefaultArgs<T>;
        Delete: GuildStarboardMessagesDeleteArgs<T>;
        DeleteMany: GuildStarboardMessagesDeleteManyArgs<T>;
        FindFirst: GuildStarboardMessagesFindFirstArgs<T>;
        FindFirstOrThrow: GuildStarboardMessagesFindFirstOrThrowArgs<T>;
        FindMany: GuildStarboardMessagesFindManyArgs<T>;
        FindUnique: GuildStarboardMessagesFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStarboardMessagesFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStarboardMessagesGroupByArgs<T>;
        Update: GuildStarboardMessagesUpdateArgs<T>;
        UpdateMany: GuildStarboardMessagesUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStarboardMessagesUpdateManyAndReturnArgs<T>;
        Upsert: GuildStarboardMessagesUpsertArgs<T>;
    };
    GuildStatusRole: {
        Aggregate: GuildStatusRoleAggregateArgs<T>;
        Count: GuildStatusRoleCountArgs<T>;
        Create: GuildStatusRoleCreateArgs<T>;
        CreateMany: GuildStatusRoleCreateManyArgs<T>;
        CreateManyAndReturn: GuildStatusRoleCreateManyAndReturnArgs<T>;
        Default: GuildStatusRoleDefaultArgs<T>;
        Delete: GuildStatusRoleDeleteArgs<T>;
        DeleteMany: GuildStatusRoleDeleteManyArgs<T>;
        FindFirst: GuildStatusRoleFindFirstArgs<T>;
        FindFirstOrThrow: GuildStatusRoleFindFirstOrThrowArgs<T>;
        FindMany: GuildStatusRoleFindManyArgs<T>;
        FindUnique: GuildStatusRoleFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStatusRoleFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStatusRoleGroupByArgs<T>;
        Update: GuildStatusRoleUpdateArgs<T>;
        UpdateMany: GuildStatusRoleUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStatusRoleUpdateManyAndReturnArgs<T>;
        Upsert: GuildStatusRoleUpsertArgs<T>;
    };
    GuildStatusRoleFilter: {
        Aggregate: GuildStatusRoleFilterAggregateArgs<T>;
        Count: GuildStatusRoleFilterCountArgs<T>;
        Create: GuildStatusRoleFilterCreateArgs<T>;
        CreateMany: GuildStatusRoleFilterCreateManyArgs<T>;
        CreateManyAndReturn: GuildStatusRoleFilterCreateManyAndReturnArgs<T>;
        Default: GuildStatusRoleFilterDefaultArgs<T>;
        Delete: GuildStatusRoleFilterDeleteArgs<T>;
        DeleteMany: GuildStatusRoleFilterDeleteManyArgs<T>;
        FindFirst: GuildStatusRoleFilterFindFirstArgs<T>;
        FindFirstOrThrow: GuildStatusRoleFilterFindFirstOrThrowArgs<T>;
        FindMany: GuildStatusRoleFilterFindManyArgs<T>;
        FindUnique: GuildStatusRoleFilterFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStatusRoleFilterFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStatusRoleFilterGroupByArgs<T>;
        Update: GuildStatusRoleFilterUpdateArgs<T>;
        UpdateMany: GuildStatusRoleFilterUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStatusRoleFilterUpdateManyAndReturnArgs<T>;
        Upsert: GuildStatusRoleFilterUpsertArgs<T>;
    };
    GuildStickyEmbedField: {
        Aggregate: GuildStickyEmbedFieldAggregateArgs<T>;
        Count: GuildStickyEmbedFieldCountArgs<T>;
        Create: GuildStickyEmbedFieldCreateArgs<T>;
        CreateMany: GuildStickyEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: GuildStickyEmbedFieldCreateManyAndReturnArgs<T>;
        Default: GuildStickyEmbedFieldDefaultArgs<T>;
        Delete: GuildStickyEmbedFieldDeleteArgs<T>;
        DeleteMany: GuildStickyEmbedFieldDeleteManyArgs<T>;
        FindFirst: GuildStickyEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: GuildStickyEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: GuildStickyEmbedFieldFindManyArgs<T>;
        FindUnique: GuildStickyEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStickyEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStickyEmbedFieldGroupByArgs<T>;
        Update: GuildStickyEmbedFieldUpdateArgs<T>;
        UpdateMany: GuildStickyEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStickyEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: GuildStickyEmbedFieldUpsertArgs<T>;
    };
    GuildStickyMessage: {
        Aggregate: GuildStickyMessageAggregateArgs<T>;
        Count: GuildStickyMessageCountArgs<T>;
        Create: GuildStickyMessageCreateArgs<T>;
        CreateMany: GuildStickyMessageCreateManyArgs<T>;
        CreateManyAndReturn: GuildStickyMessageCreateManyAndReturnArgs<T>;
        Default: GuildStickyMessageDefaultArgs<T>;
        Delete: GuildStickyMessageDeleteArgs<T>;
        DeleteMany: GuildStickyMessageDeleteManyArgs<T>;
        FindFirst: GuildStickyMessageFindFirstArgs<T>;
        FindFirstOrThrow: GuildStickyMessageFindFirstOrThrowArgs<T>;
        FindMany: GuildStickyMessageFindManyArgs<T>;
        FindUnique: GuildStickyMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStickyMessageFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStickyMessageGroupByArgs<T>;
        Update: GuildStickyMessageUpdateArgs<T>;
        UpdateMany: GuildStickyMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStickyMessageUpdateManyAndReturnArgs<T>;
        Upsert: GuildStickyMessageUpsertArgs<T>;
    };
    GuildStickyMessageButton: {
        Aggregate: GuildStickyMessageButtonAggregateArgs<T>;
        Count: GuildStickyMessageButtonCountArgs<T>;
        Create: GuildStickyMessageButtonCreateArgs<T>;
        CreateMany: GuildStickyMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: GuildStickyMessageButtonCreateManyAndReturnArgs<T>;
        Default: GuildStickyMessageButtonDefaultArgs<T>;
        Delete: GuildStickyMessageButtonDeleteArgs<T>;
        DeleteMany: GuildStickyMessageButtonDeleteManyArgs<T>;
        FindFirst: GuildStickyMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: GuildStickyMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: GuildStickyMessageButtonFindManyArgs<T>;
        FindUnique: GuildStickyMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStickyMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStickyMessageButtonGroupByArgs<T>;
        Update: GuildStickyMessageButtonUpdateArgs<T>;
        UpdateMany: GuildStickyMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStickyMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: GuildStickyMessageButtonUpsertArgs<T>;
    };
    GuildStickyMessageEmbed: {
        Aggregate: GuildStickyMessageEmbedAggregateArgs<T>;
        Count: GuildStickyMessageEmbedCountArgs<T>;
        Create: GuildStickyMessageEmbedCreateArgs<T>;
        CreateMany: GuildStickyMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: GuildStickyMessageEmbedCreateManyAndReturnArgs<T>;
        Default: GuildStickyMessageEmbedDefaultArgs<T>;
        Delete: GuildStickyMessageEmbedDeleteArgs<T>;
        DeleteMany: GuildStickyMessageEmbedDeleteManyArgs<T>;
        FindFirst: GuildStickyMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: GuildStickyMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: GuildStickyMessageEmbedFindManyArgs<T>;
        FindUnique: GuildStickyMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStickyMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStickyMessageEmbedGroupByArgs<T>;
        Update: GuildStickyMessageEmbedUpdateArgs<T>;
        UpdateMany: GuildStickyMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStickyMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: GuildStickyMessageEmbedUpsertArgs<T>;
    };
    GuildStickyMessageWebhook: {
        Aggregate: GuildStickyMessageWebhookAggregateArgs<T>;
        Count: GuildStickyMessageWebhookCountArgs<T>;
        Create: GuildStickyMessageWebhookCreateArgs<T>;
        CreateMany: GuildStickyMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: GuildStickyMessageWebhookCreateManyAndReturnArgs<T>;
        Default: GuildStickyMessageWebhookDefaultArgs<T>;
        Delete: GuildStickyMessageWebhookDeleteArgs<T>;
        DeleteMany: GuildStickyMessageWebhookDeleteManyArgs<T>;
        FindFirst: GuildStickyMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: GuildStickyMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: GuildStickyMessageWebhookFindManyArgs<T>;
        FindUnique: GuildStickyMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: GuildStickyMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: GuildStickyMessageWebhookGroupByArgs<T>;
        Update: GuildStickyMessageWebhookUpdateArgs<T>;
        UpdateMany: GuildStickyMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: GuildStickyMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: GuildStickyMessageWebhookUpsertArgs<T>;
    };
    KSCurrentlyLive: {
        Aggregate: KSCurrentlyLiveAggregateArgs<T>;
        Count: KSCurrentlyLiveCountArgs<T>;
        Create: KSCurrentlyLiveCreateArgs<T>;
        CreateMany: KSCurrentlyLiveCreateManyArgs<T>;
        CreateManyAndReturn: KSCurrentlyLiveCreateManyAndReturnArgs<T>;
        Default: KSCurrentlyLiveDefaultArgs<T>;
        Delete: KSCurrentlyLiveDeleteArgs<T>;
        DeleteMany: KSCurrentlyLiveDeleteManyArgs<T>;
        FindFirst: KSCurrentlyLiveFindFirstArgs<T>;
        FindFirstOrThrow: KSCurrentlyLiveFindFirstOrThrowArgs<T>;
        FindMany: KSCurrentlyLiveFindManyArgs<T>;
        FindUnique: KSCurrentlyLiveFindUniqueArgs<T>;
        FindUniqueOrThrow: KSCurrentlyLiveFindUniqueOrThrowArgs<T>;
        GroupBy: KSCurrentlyLiveGroupByArgs<T>;
        Update: KSCurrentlyLiveUpdateArgs<T>;
        UpdateMany: KSCurrentlyLiveUpdateManyArgs<T>;
        UpdateManyAndReturn: KSCurrentlyLiveUpdateManyAndReturnArgs<T>;
        Upsert: KSCurrentlyLiveUpsertArgs<T>;
    };
    KSCustomMessage: {
        Aggregate: KSCustomMessageAggregateArgs<T>;
        Count: KSCustomMessageCountArgs<T>;
        Create: KSCustomMessageCreateArgs<T>;
        CreateMany: KSCustomMessageCreateManyArgs<T>;
        CreateManyAndReturn: KSCustomMessageCreateManyAndReturnArgs<T>;
        Default: KSCustomMessageDefaultArgs<T>;
        Delete: KSCustomMessageDeleteArgs<T>;
        DeleteMany: KSCustomMessageDeleteManyArgs<T>;
        FindFirst: KSCustomMessageFindFirstArgs<T>;
        FindFirstOrThrow: KSCustomMessageFindFirstOrThrowArgs<T>;
        FindMany: KSCustomMessageFindManyArgs<T>;
        FindUnique: KSCustomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: KSCustomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: KSCustomMessageGroupByArgs<T>;
        Update: KSCustomMessageUpdateArgs<T>;
        UpdateMany: KSCustomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: KSCustomMessageUpdateManyAndReturnArgs<T>;
        Upsert: KSCustomMessageUpsertArgs<T>;
    };
    KSEmbedField: {
        Aggregate: KSEmbedFieldAggregateArgs<T>;
        Count: KSEmbedFieldCountArgs<T>;
        Create: KSEmbedFieldCreateArgs<T>;
        CreateMany: KSEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: KSEmbedFieldCreateManyAndReturnArgs<T>;
        Default: KSEmbedFieldDefaultArgs<T>;
        Delete: KSEmbedFieldDeleteArgs<T>;
        DeleteMany: KSEmbedFieldDeleteManyArgs<T>;
        FindFirst: KSEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: KSEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: KSEmbedFieldFindManyArgs<T>;
        FindUnique: KSEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: KSEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: KSEmbedFieldGroupByArgs<T>;
        Update: KSEmbedFieldUpdateArgs<T>;
        UpdateMany: KSEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: KSEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: KSEmbedFieldUpsertArgs<T>;
    };
    KSGiftedSubRole: {
        Aggregate: KSGiftedSubRoleAggregateArgs<T>;
        Count: KSGiftedSubRoleCountArgs<T>;
        Create: KSGiftedSubRoleCreateArgs<T>;
        CreateMany: KSGiftedSubRoleCreateManyArgs<T>;
        CreateManyAndReturn: KSGiftedSubRoleCreateManyAndReturnArgs<T>;
        Default: KSGiftedSubRoleDefaultArgs<T>;
        Delete: KSGiftedSubRoleDeleteArgs<T>;
        DeleteMany: KSGiftedSubRoleDeleteManyArgs<T>;
        FindFirst: KSGiftedSubRoleFindFirstArgs<T>;
        FindFirstOrThrow: KSGiftedSubRoleFindFirstOrThrowArgs<T>;
        FindMany: KSGiftedSubRoleFindManyArgs<T>;
        FindUnique: KSGiftedSubRoleFindUniqueArgs<T>;
        FindUniqueOrThrow: KSGiftedSubRoleFindUniqueOrThrowArgs<T>;
        GroupBy: KSGiftedSubRoleGroupByArgs<T>;
        Update: KSGiftedSubRoleUpdateArgs<T>;
        UpdateMany: KSGiftedSubRoleUpdateManyArgs<T>;
        UpdateManyAndReturn: KSGiftedSubRoleUpdateManyAndReturnArgs<T>;
        Upsert: KSGiftedSubRoleUpsertArgs<T>;
    };
    KSLeaderBoardRole: {
        Aggregate: KSLeaderBoardRoleAggregateArgs<T>;
        Count: KSLeaderBoardRoleCountArgs<T>;
        Create: KSLeaderBoardRoleCreateArgs<T>;
        CreateMany: KSLeaderBoardRoleCreateManyArgs<T>;
        CreateManyAndReturn: KSLeaderBoardRoleCreateManyAndReturnArgs<T>;
        Default: KSLeaderBoardRoleDefaultArgs<T>;
        Delete: KSLeaderBoardRoleDeleteArgs<T>;
        DeleteMany: KSLeaderBoardRoleDeleteManyArgs<T>;
        FindFirst: KSLeaderBoardRoleFindFirstArgs<T>;
        FindFirstOrThrow: KSLeaderBoardRoleFindFirstOrThrowArgs<T>;
        FindMany: KSLeaderBoardRoleFindManyArgs<T>;
        FindUnique: KSLeaderBoardRoleFindUniqueArgs<T>;
        FindUniqueOrThrow: KSLeaderBoardRoleFindUniqueOrThrowArgs<T>;
        GroupBy: KSLeaderBoardRoleGroupByArgs<T>;
        Update: KSLeaderBoardRoleUpdateArgs<T>;
        UpdateMany: KSLeaderBoardRoleUpdateManyArgs<T>;
        UpdateManyAndReturn: KSLeaderBoardRoleUpdateManyAndReturnArgs<T>;
        Upsert: KSLeaderBoardRoleUpsertArgs<T>;
    };
    KSLeaderBoardSyncRole: {
        Aggregate: KSLeaderBoardSyncRoleAggregateArgs<T>;
        Count: KSLeaderBoardSyncRoleCountArgs<T>;
        Create: KSLeaderBoardSyncRoleCreateArgs<T>;
        CreateMany: KSLeaderBoardSyncRoleCreateManyArgs<T>;
        CreateManyAndReturn: KSLeaderBoardSyncRoleCreateManyAndReturnArgs<T>;
        Default: KSLeaderBoardSyncRoleDefaultArgs<T>;
        Delete: KSLeaderBoardSyncRoleDeleteArgs<T>;
        DeleteMany: KSLeaderBoardSyncRoleDeleteManyArgs<T>;
        FindFirst: KSLeaderBoardSyncRoleFindFirstArgs<T>;
        FindFirstOrThrow: KSLeaderBoardSyncRoleFindFirstOrThrowArgs<T>;
        FindMany: KSLeaderBoardSyncRoleFindManyArgs<T>;
        FindUnique: KSLeaderBoardSyncRoleFindUniqueArgs<T>;
        FindUniqueOrThrow: KSLeaderBoardSyncRoleFindUniqueOrThrowArgs<T>;
        GroupBy: KSLeaderBoardSyncRoleGroupByArgs<T>;
        Update: KSLeaderBoardSyncRoleUpdateArgs<T>;
        UpdateMany: KSLeaderBoardSyncRoleUpdateManyArgs<T>;
        UpdateManyAndReturn: KSLeaderBoardSyncRoleUpdateManyAndReturnArgs<T>;
        Upsert: KSLeaderBoardSyncRoleUpsertArgs<T>;
    };
    KSMessageButton: {
        Aggregate: KSMessageButtonAggregateArgs<T>;
        Count: KSMessageButtonCountArgs<T>;
        Create: KSMessageButtonCreateArgs<T>;
        CreateMany: KSMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: KSMessageButtonCreateManyAndReturnArgs<T>;
        Default: KSMessageButtonDefaultArgs<T>;
        Delete: KSMessageButtonDeleteArgs<T>;
        DeleteMany: KSMessageButtonDeleteManyArgs<T>;
        FindFirst: KSMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: KSMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: KSMessageButtonFindManyArgs<T>;
        FindUnique: KSMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: KSMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: KSMessageButtonGroupByArgs<T>;
        Update: KSMessageButtonUpdateArgs<T>;
        UpdateMany: KSMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: KSMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: KSMessageButtonUpsertArgs<T>;
    };
    KSMessageEmbed: {
        Aggregate: KSMessageEmbedAggregateArgs<T>;
        Count: KSMessageEmbedCountArgs<T>;
        Create: KSMessageEmbedCreateArgs<T>;
        CreateMany: KSMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: KSMessageEmbedCreateManyAndReturnArgs<T>;
        Default: KSMessageEmbedDefaultArgs<T>;
        Delete: KSMessageEmbedDeleteArgs<T>;
        DeleteMany: KSMessageEmbedDeleteManyArgs<T>;
        FindFirst: KSMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: KSMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: KSMessageEmbedFindManyArgs<T>;
        FindUnique: KSMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: KSMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: KSMessageEmbedGroupByArgs<T>;
        Update: KSMessageEmbedUpdateArgs<T>;
        UpdateMany: KSMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: KSMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: KSMessageEmbedUpsertArgs<T>;
    };
    KSMessageWebhook: {
        Aggregate: KSMessageWebhookAggregateArgs<T>;
        Count: KSMessageWebhookCountArgs<T>;
        Create: KSMessageWebhookCreateArgs<T>;
        CreateMany: KSMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: KSMessageWebhookCreateManyAndReturnArgs<T>;
        Default: KSMessageWebhookDefaultArgs<T>;
        Delete: KSMessageWebhookDeleteArgs<T>;
        DeleteMany: KSMessageWebhookDeleteManyArgs<T>;
        FindFirst: KSMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: KSMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: KSMessageWebhookFindManyArgs<T>;
        FindUnique: KSMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: KSMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: KSMessageWebhookGroupByArgs<T>;
        Update: KSMessageWebhookUpdateArgs<T>;
        UpdateMany: KSMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: KSMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: KSMessageWebhookUpsertArgs<T>;
    };
    KSRoleWithUsers: {
        Aggregate: KSRoleWithUsersAggregateArgs<T>;
        Count: KSRoleWithUsersCountArgs<T>;
        Create: KSRoleWithUsersCreateArgs<T>;
        CreateMany: KSRoleWithUsersCreateManyArgs<T>;
        CreateManyAndReturn: KSRoleWithUsersCreateManyAndReturnArgs<T>;
        Default: KSRoleWithUsersDefaultArgs<T>;
        Delete: KSRoleWithUsersDeleteArgs<T>;
        DeleteMany: KSRoleWithUsersDeleteManyArgs<T>;
        FindFirst: KSRoleWithUsersFindFirstArgs<T>;
        FindFirstOrThrow: KSRoleWithUsersFindFirstOrThrowArgs<T>;
        FindMany: KSRoleWithUsersFindManyArgs<T>;
        FindUnique: KSRoleWithUsersFindUniqueArgs<T>;
        FindUniqueOrThrow: KSRoleWithUsersFindUniqueOrThrowArgs<T>;
        GroupBy: KSRoleWithUsersGroupByArgs<T>;
        Update: KSRoleWithUsersUpdateArgs<T>;
        UpdateMany: KSRoleWithUsersUpdateManyArgs<T>;
        UpdateManyAndReturn: KSRoleWithUsersUpdateManyAndReturnArgs<T>;
        Upsert: KSRoleWithUsersUpsertArgs<T>;
    };
    KSStatsChannelId: {
        Aggregate: KSStatsChannelIdAggregateArgs<T>;
        Count: KSStatsChannelIdCountArgs<T>;
        Create: KSStatsChannelIdCreateArgs<T>;
        CreateMany: KSStatsChannelIdCreateManyArgs<T>;
        CreateManyAndReturn: KSStatsChannelIdCreateManyAndReturnArgs<T>;
        Default: KSStatsChannelIdDefaultArgs<T>;
        Delete: KSStatsChannelIdDeleteArgs<T>;
        DeleteMany: KSStatsChannelIdDeleteManyArgs<T>;
        FindFirst: KSStatsChannelIdFindFirstArgs<T>;
        FindFirstOrThrow: KSStatsChannelIdFindFirstOrThrowArgs<T>;
        FindMany: KSStatsChannelIdFindManyArgs<T>;
        FindUnique: KSStatsChannelIdFindUniqueArgs<T>;
        FindUniqueOrThrow: KSStatsChannelIdFindUniqueOrThrowArgs<T>;
        GroupBy: KSStatsChannelIdGroupByArgs<T>;
        Update: KSStatsChannelIdUpdateArgs<T>;
        UpdateMany: KSStatsChannelIdUpdateManyArgs<T>;
        UpdateManyAndReturn: KSStatsChannelIdUpdateManyAndReturnArgs<T>;
        Upsert: KSStatsChannelIdUpsertArgs<T>;
    };
    KickStreamer: {
        Aggregate: KickStreamerAggregateArgs<T>;
        Count: KickStreamerCountArgs<T>;
        Create: KickStreamerCreateArgs<T>;
        CreateMany: KickStreamerCreateManyArgs<T>;
        CreateManyAndReturn: KickStreamerCreateManyAndReturnArgs<T>;
        Default: KickStreamerDefaultArgs<T>;
        Delete: KickStreamerDeleteArgs<T>;
        DeleteMany: KickStreamerDeleteManyArgs<T>;
        FindFirst: KickStreamerFindFirstArgs<T>;
        FindFirstOrThrow: KickStreamerFindFirstOrThrowArgs<T>;
        FindMany: KickStreamerFindManyArgs<T>;
        FindUnique: KickStreamerFindUniqueArgs<T>;
        FindUniqueOrThrow: KickStreamerFindUniqueOrThrowArgs<T>;
        GroupBy: KickStreamerGroupByArgs<T>;
        Update: KickStreamerUpdateArgs<T>;
        UpdateMany: KickStreamerUpdateManyArgs<T>;
        UpdateManyAndReturn: KickStreamerUpdateManyAndReturnArgs<T>;
        Upsert: KickStreamerUpsertArgs<T>;
    };
    Member: {
        Aggregate: MemberAggregateArgs<T>;
        Count: MemberCountArgs<T>;
        Create: MemberCreateArgs<T>;
        CreateMany: MemberCreateManyArgs<T>;
        CreateManyAndReturn: MemberCreateManyAndReturnArgs<T>;
        Default: MemberDefaultArgs<T>;
        Delete: MemberDeleteArgs<T>;
        DeleteMany: MemberDeleteManyArgs<T>;
        FindFirst: MemberFindFirstArgs<T>;
        FindFirstOrThrow: MemberFindFirstOrThrowArgs<T>;
        FindMany: MemberFindManyArgs<T>;
        FindUnique: MemberFindUniqueArgs<T>;
        FindUniqueOrThrow: MemberFindUniqueOrThrowArgs<T>;
        GroupBy: MemberGroupByArgs<T>;
        Update: MemberUpdateArgs<T>;
        UpdateMany: MemberUpdateManyArgs<T>;
        UpdateManyAndReturn: MemberUpdateManyAndReturnArgs<T>;
        Upsert: MemberUpsertArgs<T>;
    };
    R2Storage: {
        Aggregate: R2StorageAggregateArgs<T>;
        Count: R2StorageCountArgs<T>;
        Create: R2StorageCreateArgs<T>;
        CreateMany: R2StorageCreateManyArgs<T>;
        CreateManyAndReturn: R2StorageCreateManyAndReturnArgs<T>;
        Default: R2StorageDefaultArgs<T>;
        Delete: R2StorageDeleteArgs<T>;
        DeleteMany: R2StorageDeleteManyArgs<T>;
        FindFirst: R2StorageFindFirstArgs<T>;
        FindFirstOrThrow: R2StorageFindFirstOrThrowArgs<T>;
        FindMany: R2StorageFindManyArgs<T>;
        FindUnique: R2StorageFindUniqueArgs<T>;
        FindUniqueOrThrow: R2StorageFindUniqueOrThrowArgs<T>;
        GroupBy: R2StorageGroupByArgs<T>;
        Update: R2StorageUpdateArgs<T>;
        UpdateMany: R2StorageUpdateManyArgs<T>;
        UpdateManyAndReturn: R2StorageUpdateManyAndReturnArgs<T>;
        Upsert: R2StorageUpsertArgs<T>;
    };
    R2StorageGuild: {
        Aggregate: R2StorageGuildAggregateArgs<T>;
        Count: R2StorageGuildCountArgs<T>;
        Create: R2StorageGuildCreateArgs<T>;
        CreateMany: R2StorageGuildCreateManyArgs<T>;
        CreateManyAndReturn: R2StorageGuildCreateManyAndReturnArgs<T>;
        Default: R2StorageGuildDefaultArgs<T>;
        Delete: R2StorageGuildDeleteArgs<T>;
        DeleteMany: R2StorageGuildDeleteManyArgs<T>;
        FindFirst: R2StorageGuildFindFirstArgs<T>;
        FindFirstOrThrow: R2StorageGuildFindFirstOrThrowArgs<T>;
        FindMany: R2StorageGuildFindManyArgs<T>;
        FindUnique: R2StorageGuildFindUniqueArgs<T>;
        FindUniqueOrThrow: R2StorageGuildFindUniqueOrThrowArgs<T>;
        GroupBy: R2StorageGuildGroupByArgs<T>;
        Update: R2StorageGuildUpdateArgs<T>;
        UpdateMany: R2StorageGuildUpdateManyArgs<T>;
        UpdateManyAndReturn: R2StorageGuildUpdateManyAndReturnArgs<T>;
        Upsert: R2StorageGuildUpsertArgs<T>;
    };
    RSCurrentlyLive: {
        Aggregate: RSCurrentlyLiveAggregateArgs<T>;
        Count: RSCurrentlyLiveCountArgs<T>;
        Create: RSCurrentlyLiveCreateArgs<T>;
        CreateMany: RSCurrentlyLiveCreateManyArgs<T>;
        CreateManyAndReturn: RSCurrentlyLiveCreateManyAndReturnArgs<T>;
        Default: RSCurrentlyLiveDefaultArgs<T>;
        Delete: RSCurrentlyLiveDeleteArgs<T>;
        DeleteMany: RSCurrentlyLiveDeleteManyArgs<T>;
        FindFirst: RSCurrentlyLiveFindFirstArgs<T>;
        FindFirstOrThrow: RSCurrentlyLiveFindFirstOrThrowArgs<T>;
        FindMany: RSCurrentlyLiveFindManyArgs<T>;
        FindUnique: RSCurrentlyLiveFindUniqueArgs<T>;
        FindUniqueOrThrow: RSCurrentlyLiveFindUniqueOrThrowArgs<T>;
        GroupBy: RSCurrentlyLiveGroupByArgs<T>;
        Update: RSCurrentlyLiveUpdateArgs<T>;
        UpdateMany: RSCurrentlyLiveUpdateManyArgs<T>;
        UpdateManyAndReturn: RSCurrentlyLiveUpdateManyAndReturnArgs<T>;
        Upsert: RSCurrentlyLiveUpsertArgs<T>;
    };
    RSCustomMessage: {
        Aggregate: RSCustomMessageAggregateArgs<T>;
        Count: RSCustomMessageCountArgs<T>;
        Create: RSCustomMessageCreateArgs<T>;
        CreateMany: RSCustomMessageCreateManyArgs<T>;
        CreateManyAndReturn: RSCustomMessageCreateManyAndReturnArgs<T>;
        Default: RSCustomMessageDefaultArgs<T>;
        Delete: RSCustomMessageDeleteArgs<T>;
        DeleteMany: RSCustomMessageDeleteManyArgs<T>;
        FindFirst: RSCustomMessageFindFirstArgs<T>;
        FindFirstOrThrow: RSCustomMessageFindFirstOrThrowArgs<T>;
        FindMany: RSCustomMessageFindManyArgs<T>;
        FindUnique: RSCustomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: RSCustomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: RSCustomMessageGroupByArgs<T>;
        Update: RSCustomMessageUpdateArgs<T>;
        UpdateMany: RSCustomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: RSCustomMessageUpdateManyAndReturnArgs<T>;
        Upsert: RSCustomMessageUpsertArgs<T>;
    };
    RSEmbedField: {
        Aggregate: RSEmbedFieldAggregateArgs<T>;
        Count: RSEmbedFieldCountArgs<T>;
        Create: RSEmbedFieldCreateArgs<T>;
        CreateMany: RSEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: RSEmbedFieldCreateManyAndReturnArgs<T>;
        Default: RSEmbedFieldDefaultArgs<T>;
        Delete: RSEmbedFieldDeleteArgs<T>;
        DeleteMany: RSEmbedFieldDeleteManyArgs<T>;
        FindFirst: RSEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: RSEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: RSEmbedFieldFindManyArgs<T>;
        FindUnique: RSEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: RSEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: RSEmbedFieldGroupByArgs<T>;
        Update: RSEmbedFieldUpdateArgs<T>;
        UpdateMany: RSEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: RSEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: RSEmbedFieldUpsertArgs<T>;
    };
    RSMessageButton: {
        Aggregate: RSMessageButtonAggregateArgs<T>;
        Count: RSMessageButtonCountArgs<T>;
        Create: RSMessageButtonCreateArgs<T>;
        CreateMany: RSMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: RSMessageButtonCreateManyAndReturnArgs<T>;
        Default: RSMessageButtonDefaultArgs<T>;
        Delete: RSMessageButtonDeleteArgs<T>;
        DeleteMany: RSMessageButtonDeleteManyArgs<T>;
        FindFirst: RSMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: RSMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: RSMessageButtonFindManyArgs<T>;
        FindUnique: RSMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: RSMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: RSMessageButtonGroupByArgs<T>;
        Update: RSMessageButtonUpdateArgs<T>;
        UpdateMany: RSMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: RSMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: RSMessageButtonUpsertArgs<T>;
    };
    RSMessageEmbed: {
        Aggregate: RSMessageEmbedAggregateArgs<T>;
        Count: RSMessageEmbedCountArgs<T>;
        Create: RSMessageEmbedCreateArgs<T>;
        CreateMany: RSMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: RSMessageEmbedCreateManyAndReturnArgs<T>;
        Default: RSMessageEmbedDefaultArgs<T>;
        Delete: RSMessageEmbedDeleteArgs<T>;
        DeleteMany: RSMessageEmbedDeleteManyArgs<T>;
        FindFirst: RSMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: RSMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: RSMessageEmbedFindManyArgs<T>;
        FindUnique: RSMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: RSMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: RSMessageEmbedGroupByArgs<T>;
        Update: RSMessageEmbedUpdateArgs<T>;
        UpdateMany: RSMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: RSMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: RSMessageEmbedUpsertArgs<T>;
    };
    RSMessageWebhook: {
        Aggregate: RSMessageWebhookAggregateArgs<T>;
        Count: RSMessageWebhookCountArgs<T>;
        Create: RSMessageWebhookCreateArgs<T>;
        CreateMany: RSMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: RSMessageWebhookCreateManyAndReturnArgs<T>;
        Default: RSMessageWebhookDefaultArgs<T>;
        Delete: RSMessageWebhookDeleteArgs<T>;
        DeleteMany: RSMessageWebhookDeleteManyArgs<T>;
        FindFirst: RSMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: RSMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: RSMessageWebhookFindManyArgs<T>;
        FindUnique: RSMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: RSMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: RSMessageWebhookGroupByArgs<T>;
        Update: RSMessageWebhookUpdateArgs<T>;
        UpdateMany: RSMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: RSMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: RSMessageWebhookUpsertArgs<T>;
    };
    RSStatsChannelId: {
        Aggregate: RSStatsChannelIdAggregateArgs<T>;
        Count: RSStatsChannelIdCountArgs<T>;
        Create: RSStatsChannelIdCreateArgs<T>;
        CreateMany: RSStatsChannelIdCreateManyArgs<T>;
        CreateManyAndReturn: RSStatsChannelIdCreateManyAndReturnArgs<T>;
        Default: RSStatsChannelIdDefaultArgs<T>;
        Delete: RSStatsChannelIdDeleteArgs<T>;
        DeleteMany: RSStatsChannelIdDeleteManyArgs<T>;
        FindFirst: RSStatsChannelIdFindFirstArgs<T>;
        FindFirstOrThrow: RSStatsChannelIdFindFirstOrThrowArgs<T>;
        FindMany: RSStatsChannelIdFindManyArgs<T>;
        FindUnique: RSStatsChannelIdFindUniqueArgs<T>;
        FindUniqueOrThrow: RSStatsChannelIdFindUniqueOrThrowArgs<T>;
        GroupBy: RSStatsChannelIdGroupByArgs<T>;
        Update: RSStatsChannelIdUpdateArgs<T>;
        UpdateMany: RSStatsChannelIdUpdateManyArgs<T>;
        UpdateManyAndReturn: RSStatsChannelIdUpdateManyAndReturnArgs<T>;
        Upsert: RSStatsChannelIdUpsertArgs<T>;
    };
    RumbleStreamer: {
        Aggregate: RumbleStreamerAggregateArgs<T>;
        Count: RumbleStreamerCountArgs<T>;
        Create: RumbleStreamerCreateArgs<T>;
        CreateMany: RumbleStreamerCreateManyArgs<T>;
        CreateManyAndReturn: RumbleStreamerCreateManyAndReturnArgs<T>;
        Default: RumbleStreamerDefaultArgs<T>;
        Delete: RumbleStreamerDeleteArgs<T>;
        DeleteMany: RumbleStreamerDeleteManyArgs<T>;
        FindFirst: RumbleStreamerFindFirstArgs<T>;
        FindFirstOrThrow: RumbleStreamerFindFirstOrThrowArgs<T>;
        FindMany: RumbleStreamerFindManyArgs<T>;
        FindUnique: RumbleStreamerFindUniqueArgs<T>;
        FindUniqueOrThrow: RumbleStreamerFindUniqueOrThrowArgs<T>;
        GroupBy: RumbleStreamerGroupByArgs<T>;
        Update: RumbleStreamerUpdateArgs<T>;
        UpdateMany: RumbleStreamerUpdateManyArgs<T>;
        UpdateManyAndReturn: RumbleStreamerUpdateManyAndReturnArgs<T>;
        Upsert: RumbleStreamerUpsertArgs<T>;
    };
    SentDrop: {
        Aggregate: SentDropAggregateArgs<T>;
        Count: SentDropCountArgs<T>;
        Create: SentDropCreateArgs<T>;
        CreateMany: SentDropCreateManyArgs<T>;
        CreateManyAndReturn: SentDropCreateManyAndReturnArgs<T>;
        Default: SentDropDefaultArgs<T>;
        Delete: SentDropDeleteArgs<T>;
        DeleteMany: SentDropDeleteManyArgs<T>;
        FindFirst: SentDropFindFirstArgs<T>;
        FindFirstOrThrow: SentDropFindFirstOrThrowArgs<T>;
        FindMany: SentDropFindManyArgs<T>;
        FindUnique: SentDropFindUniqueArgs<T>;
        FindUniqueOrThrow: SentDropFindUniqueOrThrowArgs<T>;
        GroupBy: SentDropGroupByArgs<T>;
        Update: SentDropUpdateArgs<T>;
        UpdateMany: SentDropUpdateManyArgs<T>;
        UpdateManyAndReturn: SentDropUpdateManyAndReturnArgs<T>;
        Upsert: SentDropUpsertArgs<T>;
    };
    TSCurrentlyLive: {
        Aggregate: TSCurrentlyLiveAggregateArgs<T>;
        Count: TSCurrentlyLiveCountArgs<T>;
        Create: TSCurrentlyLiveCreateArgs<T>;
        CreateMany: TSCurrentlyLiveCreateManyArgs<T>;
        CreateManyAndReturn: TSCurrentlyLiveCreateManyAndReturnArgs<T>;
        Default: TSCurrentlyLiveDefaultArgs<T>;
        Delete: TSCurrentlyLiveDeleteArgs<T>;
        DeleteMany: TSCurrentlyLiveDeleteManyArgs<T>;
        FindFirst: TSCurrentlyLiveFindFirstArgs<T>;
        FindFirstOrThrow: TSCurrentlyLiveFindFirstOrThrowArgs<T>;
        FindMany: TSCurrentlyLiveFindManyArgs<T>;
        FindUnique: TSCurrentlyLiveFindUniqueArgs<T>;
        FindUniqueOrThrow: TSCurrentlyLiveFindUniqueOrThrowArgs<T>;
        GroupBy: TSCurrentlyLiveGroupByArgs<T>;
        Update: TSCurrentlyLiveUpdateArgs<T>;
        UpdateMany: TSCurrentlyLiveUpdateManyArgs<T>;
        UpdateManyAndReturn: TSCurrentlyLiveUpdateManyAndReturnArgs<T>;
        Upsert: TSCurrentlyLiveUpsertArgs<T>;
    };
    TSCustomMessage: {
        Aggregate: TSCustomMessageAggregateArgs<T>;
        Count: TSCustomMessageCountArgs<T>;
        Create: TSCustomMessageCreateArgs<T>;
        CreateMany: TSCustomMessageCreateManyArgs<T>;
        CreateManyAndReturn: TSCustomMessageCreateManyAndReturnArgs<T>;
        Default: TSCustomMessageDefaultArgs<T>;
        Delete: TSCustomMessageDeleteArgs<T>;
        DeleteMany: TSCustomMessageDeleteManyArgs<T>;
        FindFirst: TSCustomMessageFindFirstArgs<T>;
        FindFirstOrThrow: TSCustomMessageFindFirstOrThrowArgs<T>;
        FindMany: TSCustomMessageFindManyArgs<T>;
        FindUnique: TSCustomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: TSCustomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: TSCustomMessageGroupByArgs<T>;
        Update: TSCustomMessageUpdateArgs<T>;
        UpdateMany: TSCustomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: TSCustomMessageUpdateManyAndReturnArgs<T>;
        Upsert: TSCustomMessageUpsertArgs<T>;
    };
    TSEmbedField: {
        Aggregate: TSEmbedFieldAggregateArgs<T>;
        Count: TSEmbedFieldCountArgs<T>;
        Create: TSEmbedFieldCreateArgs<T>;
        CreateMany: TSEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: TSEmbedFieldCreateManyAndReturnArgs<T>;
        Default: TSEmbedFieldDefaultArgs<T>;
        Delete: TSEmbedFieldDeleteArgs<T>;
        DeleteMany: TSEmbedFieldDeleteManyArgs<T>;
        FindFirst: TSEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: TSEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: TSEmbedFieldFindManyArgs<T>;
        FindUnique: TSEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: TSEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: TSEmbedFieldGroupByArgs<T>;
        Update: TSEmbedFieldUpdateArgs<T>;
        UpdateMany: TSEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: TSEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: TSEmbedFieldUpsertArgs<T>;
    };
    TSMessageButton: {
        Aggregate: TSMessageButtonAggregateArgs<T>;
        Count: TSMessageButtonCountArgs<T>;
        Create: TSMessageButtonCreateArgs<T>;
        CreateMany: TSMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: TSMessageButtonCreateManyAndReturnArgs<T>;
        Default: TSMessageButtonDefaultArgs<T>;
        Delete: TSMessageButtonDeleteArgs<T>;
        DeleteMany: TSMessageButtonDeleteManyArgs<T>;
        FindFirst: TSMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: TSMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: TSMessageButtonFindManyArgs<T>;
        FindUnique: TSMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: TSMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: TSMessageButtonGroupByArgs<T>;
        Update: TSMessageButtonUpdateArgs<T>;
        UpdateMany: TSMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: TSMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: TSMessageButtonUpsertArgs<T>;
    };
    TSMessageEmbed: {
        Aggregate: TSMessageEmbedAggregateArgs<T>;
        Count: TSMessageEmbedCountArgs<T>;
        Create: TSMessageEmbedCreateArgs<T>;
        CreateMany: TSMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: TSMessageEmbedCreateManyAndReturnArgs<T>;
        Default: TSMessageEmbedDefaultArgs<T>;
        Delete: TSMessageEmbedDeleteArgs<T>;
        DeleteMany: TSMessageEmbedDeleteManyArgs<T>;
        FindFirst: TSMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: TSMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: TSMessageEmbedFindManyArgs<T>;
        FindUnique: TSMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: TSMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: TSMessageEmbedGroupByArgs<T>;
        Update: TSMessageEmbedUpdateArgs<T>;
        UpdateMany: TSMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: TSMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: TSMessageEmbedUpsertArgs<T>;
    };
    TSMessageWebhook: {
        Aggregate: TSMessageWebhookAggregateArgs<T>;
        Count: TSMessageWebhookCountArgs<T>;
        Create: TSMessageWebhookCreateArgs<T>;
        CreateMany: TSMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: TSMessageWebhookCreateManyAndReturnArgs<T>;
        Default: TSMessageWebhookDefaultArgs<T>;
        Delete: TSMessageWebhookDeleteArgs<T>;
        DeleteMany: TSMessageWebhookDeleteManyArgs<T>;
        FindFirst: TSMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: TSMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: TSMessageWebhookFindManyArgs<T>;
        FindUnique: TSMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: TSMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: TSMessageWebhookGroupByArgs<T>;
        Update: TSMessageWebhookUpdateArgs<T>;
        UpdateMany: TSMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: TSMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: TSMessageWebhookUpsertArgs<T>;
    };
    TSStatsChannelId: {
        Aggregate: TSStatsChannelIdAggregateArgs<T>;
        Count: TSStatsChannelIdCountArgs<T>;
        Create: TSStatsChannelIdCreateArgs<T>;
        CreateMany: TSStatsChannelIdCreateManyArgs<T>;
        CreateManyAndReturn: TSStatsChannelIdCreateManyAndReturnArgs<T>;
        Default: TSStatsChannelIdDefaultArgs<T>;
        Delete: TSStatsChannelIdDeleteArgs<T>;
        DeleteMany: TSStatsChannelIdDeleteManyArgs<T>;
        FindFirst: TSStatsChannelIdFindFirstArgs<T>;
        FindFirstOrThrow: TSStatsChannelIdFindFirstOrThrowArgs<T>;
        FindMany: TSStatsChannelIdFindManyArgs<T>;
        FindUnique: TSStatsChannelIdFindUniqueArgs<T>;
        FindUniqueOrThrow: TSStatsChannelIdFindUniqueOrThrowArgs<T>;
        GroupBy: TSStatsChannelIdGroupByArgs<T>;
        Update: TSStatsChannelIdUpdateArgs<T>;
        UpdateMany: TSStatsChannelIdUpdateManyArgs<T>;
        UpdateManyAndReturn: TSStatsChannelIdUpdateManyAndReturnArgs<T>;
        Upsert: TSStatsChannelIdUpsertArgs<T>;
    };
    TTSCurrentlyLive: {
        Aggregate: TTSCurrentlyLiveAggregateArgs<T>;
        Count: TTSCurrentlyLiveCountArgs<T>;
        Create: TTSCurrentlyLiveCreateArgs<T>;
        CreateMany: TTSCurrentlyLiveCreateManyArgs<T>;
        CreateManyAndReturn: TTSCurrentlyLiveCreateManyAndReturnArgs<T>;
        Default: TTSCurrentlyLiveDefaultArgs<T>;
        Delete: TTSCurrentlyLiveDeleteArgs<T>;
        DeleteMany: TTSCurrentlyLiveDeleteManyArgs<T>;
        FindFirst: TTSCurrentlyLiveFindFirstArgs<T>;
        FindFirstOrThrow: TTSCurrentlyLiveFindFirstOrThrowArgs<T>;
        FindMany: TTSCurrentlyLiveFindManyArgs<T>;
        FindUnique: TTSCurrentlyLiveFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSCurrentlyLiveFindUniqueOrThrowArgs<T>;
        GroupBy: TTSCurrentlyLiveGroupByArgs<T>;
        Update: TTSCurrentlyLiveUpdateArgs<T>;
        UpdateMany: TTSCurrentlyLiveUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSCurrentlyLiveUpdateManyAndReturnArgs<T>;
        Upsert: TTSCurrentlyLiveUpsertArgs<T>;
    };
    TTSCustomMessage: {
        Aggregate: TTSCustomMessageAggregateArgs<T>;
        Count: TTSCustomMessageCountArgs<T>;
        Create: TTSCustomMessageCreateArgs<T>;
        CreateMany: TTSCustomMessageCreateManyArgs<T>;
        CreateManyAndReturn: TTSCustomMessageCreateManyAndReturnArgs<T>;
        Default: TTSCustomMessageDefaultArgs<T>;
        Delete: TTSCustomMessageDeleteArgs<T>;
        DeleteMany: TTSCustomMessageDeleteManyArgs<T>;
        FindFirst: TTSCustomMessageFindFirstArgs<T>;
        FindFirstOrThrow: TTSCustomMessageFindFirstOrThrowArgs<T>;
        FindMany: TTSCustomMessageFindManyArgs<T>;
        FindUnique: TTSCustomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSCustomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: TTSCustomMessageGroupByArgs<T>;
        Update: TTSCustomMessageUpdateArgs<T>;
        UpdateMany: TTSCustomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSCustomMessageUpdateManyAndReturnArgs<T>;
        Upsert: TTSCustomMessageUpsertArgs<T>;
    };
    TTSEmbedField: {
        Aggregate: TTSEmbedFieldAggregateArgs<T>;
        Count: TTSEmbedFieldCountArgs<T>;
        Create: TTSEmbedFieldCreateArgs<T>;
        CreateMany: TTSEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: TTSEmbedFieldCreateManyAndReturnArgs<T>;
        Default: TTSEmbedFieldDefaultArgs<T>;
        Delete: TTSEmbedFieldDeleteArgs<T>;
        DeleteMany: TTSEmbedFieldDeleteManyArgs<T>;
        FindFirst: TTSEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: TTSEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: TTSEmbedFieldFindManyArgs<T>;
        FindUnique: TTSEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: TTSEmbedFieldGroupByArgs<T>;
        Update: TTSEmbedFieldUpdateArgs<T>;
        UpdateMany: TTSEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: TTSEmbedFieldUpsertArgs<T>;
    };
    TTSMessageButton: {
        Aggregate: TTSMessageButtonAggregateArgs<T>;
        Count: TTSMessageButtonCountArgs<T>;
        Create: TTSMessageButtonCreateArgs<T>;
        CreateMany: TTSMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: TTSMessageButtonCreateManyAndReturnArgs<T>;
        Default: TTSMessageButtonDefaultArgs<T>;
        Delete: TTSMessageButtonDeleteArgs<T>;
        DeleteMany: TTSMessageButtonDeleteManyArgs<T>;
        FindFirst: TTSMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: TTSMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: TTSMessageButtonFindManyArgs<T>;
        FindUnique: TTSMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: TTSMessageButtonGroupByArgs<T>;
        Update: TTSMessageButtonUpdateArgs<T>;
        UpdateMany: TTSMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: TTSMessageButtonUpsertArgs<T>;
    };
    TTSMessageEmbed: {
        Aggregate: TTSMessageEmbedAggregateArgs<T>;
        Count: TTSMessageEmbedCountArgs<T>;
        Create: TTSMessageEmbedCreateArgs<T>;
        CreateMany: TTSMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: TTSMessageEmbedCreateManyAndReturnArgs<T>;
        Default: TTSMessageEmbedDefaultArgs<T>;
        Delete: TTSMessageEmbedDeleteArgs<T>;
        DeleteMany: TTSMessageEmbedDeleteManyArgs<T>;
        FindFirst: TTSMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: TTSMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: TTSMessageEmbedFindManyArgs<T>;
        FindUnique: TTSMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: TTSMessageEmbedGroupByArgs<T>;
        Update: TTSMessageEmbedUpdateArgs<T>;
        UpdateMany: TTSMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: TTSMessageEmbedUpsertArgs<T>;
    };
    TTSMessageWebhook: {
        Aggregate: TTSMessageWebhookAggregateArgs<T>;
        Count: TTSMessageWebhookCountArgs<T>;
        Create: TTSMessageWebhookCreateArgs<T>;
        CreateMany: TTSMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: TTSMessageWebhookCreateManyAndReturnArgs<T>;
        Default: TTSMessageWebhookDefaultArgs<T>;
        Delete: TTSMessageWebhookDeleteArgs<T>;
        DeleteMany: TTSMessageWebhookDeleteManyArgs<T>;
        FindFirst: TTSMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: TTSMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: TTSMessageWebhookFindManyArgs<T>;
        FindUnique: TTSMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: TTSMessageWebhookGroupByArgs<T>;
        Update: TTSMessageWebhookUpdateArgs<T>;
        UpdateMany: TTSMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: TTSMessageWebhookUpsertArgs<T>;
    };
    TTSStatsChannelId: {
        Aggregate: TTSStatsChannelIdAggregateArgs<T>;
        Count: TTSStatsChannelIdCountArgs<T>;
        Create: TTSStatsChannelIdCreateArgs<T>;
        CreateMany: TTSStatsChannelIdCreateManyArgs<T>;
        CreateManyAndReturn: TTSStatsChannelIdCreateManyAndReturnArgs<T>;
        Default: TTSStatsChannelIdDefaultArgs<T>;
        Delete: TTSStatsChannelIdDeleteArgs<T>;
        DeleteMany: TTSStatsChannelIdDeleteManyArgs<T>;
        FindFirst: TTSStatsChannelIdFindFirstArgs<T>;
        FindFirstOrThrow: TTSStatsChannelIdFindFirstOrThrowArgs<T>;
        FindMany: TTSStatsChannelIdFindManyArgs<T>;
        FindUnique: TTSStatsChannelIdFindUniqueArgs<T>;
        FindUniqueOrThrow: TTSStatsChannelIdFindUniqueOrThrowArgs<T>;
        GroupBy: TTSStatsChannelIdGroupByArgs<T>;
        Update: TTSStatsChannelIdUpdateArgs<T>;
        UpdateMany: TTSStatsChannelIdUpdateManyArgs<T>;
        UpdateManyAndReturn: TTSStatsChannelIdUpdateManyAndReturnArgs<T>;
        Upsert: TTSStatsChannelIdUpsertArgs<T>;
    };
    Team: {
        Aggregate: TeamAggregateArgs<T>;
        Count: TeamCountArgs<T>;
        Create: TeamCreateArgs<T>;
        CreateMany: TeamCreateManyArgs<T>;
        CreateManyAndReturn: TeamCreateManyAndReturnArgs<T>;
        Default: TeamDefaultArgs<T>;
        Delete: TeamDeleteArgs<T>;
        DeleteMany: TeamDeleteManyArgs<T>;
        FindFirst: TeamFindFirstArgs<T>;
        FindFirstOrThrow: TeamFindFirstOrThrowArgs<T>;
        FindMany: TeamFindManyArgs<T>;
        FindUnique: TeamFindUniqueArgs<T>;
        FindUniqueOrThrow: TeamFindUniqueOrThrowArgs<T>;
        GroupBy: TeamGroupByArgs<T>;
        Update: TeamUpdateArgs<T>;
        UpdateMany: TeamUpdateManyArgs<T>;
        UpdateManyAndReturn: TeamUpdateManyAndReturnArgs<T>;
        Upsert: TeamUpsertArgs<T>;
    };
    TeamMember: {
        Aggregate: TeamMemberAggregateArgs<T>;
        Count: TeamMemberCountArgs<T>;
        Create: TeamMemberCreateArgs<T>;
        CreateMany: TeamMemberCreateManyArgs<T>;
        CreateManyAndReturn: TeamMemberCreateManyAndReturnArgs<T>;
        Default: TeamMemberDefaultArgs<T>;
        Delete: TeamMemberDeleteArgs<T>;
        DeleteMany: TeamMemberDeleteManyArgs<T>;
        FindFirst: TeamMemberFindFirstArgs<T>;
        FindFirstOrThrow: TeamMemberFindFirstOrThrowArgs<T>;
        FindMany: TeamMemberFindManyArgs<T>;
        FindUnique: TeamMemberFindUniqueArgs<T>;
        FindUniqueOrThrow: TeamMemberFindUniqueOrThrowArgs<T>;
        GroupBy: TeamMemberGroupByArgs<T>;
        Update: TeamMemberUpdateArgs<T>;
        UpdateMany: TeamMemberUpdateManyArgs<T>;
        UpdateManyAndReturn: TeamMemberUpdateManyAndReturnArgs<T>;
        Upsert: TeamMemberUpsertArgs<T>;
    };
    TiktokStreamer: {
        Aggregate: TiktokStreamerAggregateArgs<T>;
        Count: TiktokStreamerCountArgs<T>;
        Create: TiktokStreamerCreateArgs<T>;
        CreateMany: TiktokStreamerCreateManyArgs<T>;
        CreateManyAndReturn: TiktokStreamerCreateManyAndReturnArgs<T>;
        Default: TiktokStreamerDefaultArgs<T>;
        Delete: TiktokStreamerDeleteArgs<T>;
        DeleteMany: TiktokStreamerDeleteManyArgs<T>;
        FindFirst: TiktokStreamerFindFirstArgs<T>;
        FindFirstOrThrow: TiktokStreamerFindFirstOrThrowArgs<T>;
        FindMany: TiktokStreamerFindManyArgs<T>;
        FindUnique: TiktokStreamerFindUniqueArgs<T>;
        FindUniqueOrThrow: TiktokStreamerFindUniqueOrThrowArgs<T>;
        GroupBy: TiktokStreamerGroupByArgs<T>;
        Update: TiktokStreamerUpdateArgs<T>;
        UpdateMany: TiktokStreamerUpdateManyArgs<T>;
        UpdateManyAndReturn: TiktokStreamerUpdateManyAndReturnArgs<T>;
        Upsert: TiktokStreamerUpsertArgs<T>;
    };
    TwitchStreamer: {
        Aggregate: TwitchStreamerAggregateArgs<T>;
        Count: TwitchStreamerCountArgs<T>;
        Create: TwitchStreamerCreateArgs<T>;
        CreateMany: TwitchStreamerCreateManyArgs<T>;
        CreateManyAndReturn: TwitchStreamerCreateManyAndReturnArgs<T>;
        Default: TwitchStreamerDefaultArgs<T>;
        Delete: TwitchStreamerDeleteArgs<T>;
        DeleteMany: TwitchStreamerDeleteManyArgs<T>;
        FindFirst: TwitchStreamerFindFirstArgs<T>;
        FindFirstOrThrow: TwitchStreamerFindFirstOrThrowArgs<T>;
        FindMany: TwitchStreamerFindManyArgs<T>;
        FindUnique: TwitchStreamerFindUniqueArgs<T>;
        FindUniqueOrThrow: TwitchStreamerFindUniqueOrThrowArgs<T>;
        GroupBy: TwitchStreamerGroupByArgs<T>;
        Update: TwitchStreamerUpdateArgs<T>;
        UpdateMany: TwitchStreamerUpdateManyArgs<T>;
        UpdateManyAndReturn: TwitchStreamerUpdateManyAndReturnArgs<T>;
        Upsert: TwitchStreamerUpsertArgs<T>;
    };
    User: {
        Aggregate: UserAggregateArgs<T>;
        Count: UserCountArgs<T>;
        Create: UserCreateArgs<T>;
        CreateMany: UserCreateManyArgs<T>;
        CreateManyAndReturn: UserCreateManyAndReturnArgs<T>;
        Default: UserDefaultArgs<T>;
        Delete: UserDeleteArgs<T>;
        DeleteMany: UserDeleteManyArgs<T>;
        FindFirst: UserFindFirstArgs<T>;
        FindFirstOrThrow: UserFindFirstOrThrowArgs<T>;
        FindMany: UserFindManyArgs<T>;
        FindUnique: UserFindUniqueArgs<T>;
        FindUniqueOrThrow: UserFindUniqueOrThrowArgs<T>;
        GroupBy: UserGroupByArgs<T>;
        Update: UserUpdateArgs<T>;
        UpdateMany: UserUpdateManyArgs<T>;
        UpdateManyAndReturn: UserUpdateManyAndReturnArgs<T>;
        Upsert: UserUpsertArgs<T>;
    };
    UserActiveGuildSubscription: {
        Aggregate: UserActiveGuildSubscriptionAggregateArgs<T>;
        Count: UserActiveGuildSubscriptionCountArgs<T>;
        Create: UserActiveGuildSubscriptionCreateArgs<T>;
        CreateMany: UserActiveGuildSubscriptionCreateManyArgs<T>;
        CreateManyAndReturn: UserActiveGuildSubscriptionCreateManyAndReturnArgs<T>;
        Default: UserActiveGuildSubscriptionDefaultArgs<T>;
        Delete: UserActiveGuildSubscriptionDeleteArgs<T>;
        DeleteMany: UserActiveGuildSubscriptionDeleteManyArgs<T>;
        FindFirst: UserActiveGuildSubscriptionFindFirstArgs<T>;
        FindFirstOrThrow: UserActiveGuildSubscriptionFindFirstOrThrowArgs<T>;
        FindMany: UserActiveGuildSubscriptionFindManyArgs<T>;
        FindUnique: UserActiveGuildSubscriptionFindUniqueArgs<T>;
        FindUniqueOrThrow: UserActiveGuildSubscriptionFindUniqueOrThrowArgs<T>;
        GroupBy: UserActiveGuildSubscriptionGroupByArgs<T>;
        Update: UserActiveGuildSubscriptionUpdateArgs<T>;
        UpdateMany: UserActiveGuildSubscriptionUpdateManyArgs<T>;
        UpdateManyAndReturn: UserActiveGuildSubscriptionUpdateManyAndReturnArgs<T>;
        Upsert: UserActiveGuildSubscriptionUpsertArgs<T>;
    };
    UserBirthday: {
        Aggregate: UserBirthdayAggregateArgs<T>;
        Count: UserBirthdayCountArgs<T>;
        Create: UserBirthdayCreateArgs<T>;
        CreateMany: UserBirthdayCreateManyArgs<T>;
        CreateManyAndReturn: UserBirthdayCreateManyAndReturnArgs<T>;
        Default: UserBirthdayDefaultArgs<T>;
        Delete: UserBirthdayDeleteArgs<T>;
        DeleteMany: UserBirthdayDeleteManyArgs<T>;
        FindFirst: UserBirthdayFindFirstArgs<T>;
        FindFirstOrThrow: UserBirthdayFindFirstOrThrowArgs<T>;
        FindMany: UserBirthdayFindManyArgs<T>;
        FindUnique: UserBirthdayFindUniqueArgs<T>;
        FindUniqueOrThrow: UserBirthdayFindUniqueOrThrowArgs<T>;
        GroupBy: UserBirthdayGroupByArgs<T>;
        Update: UserBirthdayUpdateArgs<T>;
        UpdateMany: UserBirthdayUpdateManyArgs<T>;
        UpdateManyAndReturn: UserBirthdayUpdateManyAndReturnArgs<T>;
        Upsert: UserBirthdayUpsertArgs<T>;
    };
    UserGettingStarted: {
        Aggregate: UserGettingStartedAggregateArgs<T>;
        Count: UserGettingStartedCountArgs<T>;
        Create: UserGettingStartedCreateArgs<T>;
        CreateMany: UserGettingStartedCreateManyArgs<T>;
        CreateManyAndReturn: UserGettingStartedCreateManyAndReturnArgs<T>;
        Default: UserGettingStartedDefaultArgs<T>;
        Delete: UserGettingStartedDeleteArgs<T>;
        DeleteMany: UserGettingStartedDeleteManyArgs<T>;
        FindFirst: UserGettingStartedFindFirstArgs<T>;
        FindFirstOrThrow: UserGettingStartedFindFirstOrThrowArgs<T>;
        FindMany: UserGettingStartedFindManyArgs<T>;
        FindUnique: UserGettingStartedFindUniqueArgs<T>;
        FindUniqueOrThrow: UserGettingStartedFindUniqueOrThrowArgs<T>;
        GroupBy: UserGettingStartedGroupByArgs<T>;
        Update: UserGettingStartedUpdateArgs<T>;
        UpdateMany: UserGettingStartedUpdateManyArgs<T>;
        UpdateManyAndReturn: UserGettingStartedUpdateManyAndReturnArgs<T>;
        Upsert: UserGettingStartedUpsertArgs<T>;
    };
    UserKickAccount: {
        Aggregate: UserKickAccountAggregateArgs<T>;
        Count: UserKickAccountCountArgs<T>;
        Create: UserKickAccountCreateArgs<T>;
        CreateMany: UserKickAccountCreateManyArgs<T>;
        CreateManyAndReturn: UserKickAccountCreateManyAndReturnArgs<T>;
        Default: UserKickAccountDefaultArgs<T>;
        Delete: UserKickAccountDeleteArgs<T>;
        DeleteMany: UserKickAccountDeleteManyArgs<T>;
        FindFirst: UserKickAccountFindFirstArgs<T>;
        FindFirstOrThrow: UserKickAccountFindFirstOrThrowArgs<T>;
        FindMany: UserKickAccountFindManyArgs<T>;
        FindUnique: UserKickAccountFindUniqueArgs<T>;
        FindUniqueOrThrow: UserKickAccountFindUniqueOrThrowArgs<T>;
        GroupBy: UserKickAccountGroupByArgs<T>;
        Update: UserKickAccountUpdateArgs<T>;
        UpdateMany: UserKickAccountUpdateManyArgs<T>;
        UpdateManyAndReturn: UserKickAccountUpdateManyAndReturnArgs<T>;
        Upsert: UserKickAccountUpsertArgs<T>;
    };
    UserKickAccountSubscribedTo: {
        Aggregate: UserKickAccountSubscribedToAggregateArgs<T>;
        Count: UserKickAccountSubscribedToCountArgs<T>;
        Create: UserKickAccountSubscribedToCreateArgs<T>;
        CreateMany: UserKickAccountSubscribedToCreateManyArgs<T>;
        CreateManyAndReturn: UserKickAccountSubscribedToCreateManyAndReturnArgs<T>;
        Default: UserKickAccountSubscribedToDefaultArgs<T>;
        Delete: UserKickAccountSubscribedToDeleteArgs<T>;
        DeleteMany: UserKickAccountSubscribedToDeleteManyArgs<T>;
        FindFirst: UserKickAccountSubscribedToFindFirstArgs<T>;
        FindFirstOrThrow: UserKickAccountSubscribedToFindFirstOrThrowArgs<T>;
        FindMany: UserKickAccountSubscribedToFindManyArgs<T>;
        FindUnique: UserKickAccountSubscribedToFindUniqueArgs<T>;
        FindUniqueOrThrow: UserKickAccountSubscribedToFindUniqueOrThrowArgs<T>;
        GroupBy: UserKickAccountSubscribedToGroupByArgs<T>;
        Update: UserKickAccountSubscribedToUpdateArgs<T>;
        UpdateMany: UserKickAccountSubscribedToUpdateManyArgs<T>;
        UpdateManyAndReturn: UserKickAccountSubscribedToUpdateManyAndReturnArgs<T>;
        Upsert: UserKickAccountSubscribedToUpsertArgs<T>;
    };
    UserLinkedRoles: {
        Aggregate: UserLinkedRolesAggregateArgs<T>;
        Count: UserLinkedRolesCountArgs<T>;
        Create: UserLinkedRolesCreateArgs<T>;
        CreateMany: UserLinkedRolesCreateManyArgs<T>;
        CreateManyAndReturn: UserLinkedRolesCreateManyAndReturnArgs<T>;
        Default: UserLinkedRolesDefaultArgs<T>;
        Delete: UserLinkedRolesDeleteArgs<T>;
        DeleteMany: UserLinkedRolesDeleteManyArgs<T>;
        FindFirst: UserLinkedRolesFindFirstArgs<T>;
        FindFirstOrThrow: UserLinkedRolesFindFirstOrThrowArgs<T>;
        FindMany: UserLinkedRolesFindManyArgs<T>;
        FindUnique: UserLinkedRolesFindUniqueArgs<T>;
        FindUniqueOrThrow: UserLinkedRolesFindUniqueOrThrowArgs<T>;
        GroupBy: UserLinkedRolesGroupByArgs<T>;
        Update: UserLinkedRolesUpdateArgs<T>;
        UpdateMany: UserLinkedRolesUpdateManyArgs<T>;
        UpdateManyAndReturn: UserLinkedRolesUpdateManyAndReturnArgs<T>;
        Upsert: UserLinkedRolesUpsertArgs<T>;
    };
    UserMediaShare: {
        Aggregate: UserMediaShareAggregateArgs<T>;
        Count: UserMediaShareCountArgs<T>;
        Create: UserMediaShareCreateArgs<T>;
        CreateMany: UserMediaShareCreateManyArgs<T>;
        CreateManyAndReturn: UserMediaShareCreateManyAndReturnArgs<T>;
        Default: UserMediaShareDefaultArgs<T>;
        Delete: UserMediaShareDeleteArgs<T>;
        DeleteMany: UserMediaShareDeleteManyArgs<T>;
        FindFirst: UserMediaShareFindFirstArgs<T>;
        FindFirstOrThrow: UserMediaShareFindFirstOrThrowArgs<T>;
        FindMany: UserMediaShareFindManyArgs<T>;
        FindUnique: UserMediaShareFindUniqueArgs<T>;
        FindUniqueOrThrow: UserMediaShareFindUniqueOrThrowArgs<T>;
        GroupBy: UserMediaShareGroupByArgs<T>;
        Update: UserMediaShareUpdateArgs<T>;
        UpdateMany: UserMediaShareUpdateManyArgs<T>;
        UpdateManyAndReturn: UserMediaShareUpdateManyAndReturnArgs<T>;
        Upsert: UserMediaShareUpsertArgs<T>;
    };
    UserMediaSharePermissions: {
        Aggregate: UserMediaSharePermissionsAggregateArgs<T>;
        Count: UserMediaSharePermissionsCountArgs<T>;
        Create: UserMediaSharePermissionsCreateArgs<T>;
        CreateMany: UserMediaSharePermissionsCreateManyArgs<T>;
        CreateManyAndReturn: UserMediaSharePermissionsCreateManyAndReturnArgs<T>;
        Default: UserMediaSharePermissionsDefaultArgs<T>;
        Delete: UserMediaSharePermissionsDeleteArgs<T>;
        DeleteMany: UserMediaSharePermissionsDeleteManyArgs<T>;
        FindFirst: UserMediaSharePermissionsFindFirstArgs<T>;
        FindFirstOrThrow: UserMediaSharePermissionsFindFirstOrThrowArgs<T>;
        FindMany: UserMediaSharePermissionsFindManyArgs<T>;
        FindUnique: UserMediaSharePermissionsFindUniqueArgs<T>;
        FindUniqueOrThrow: UserMediaSharePermissionsFindUniqueOrThrowArgs<T>;
        GroupBy: UserMediaSharePermissionsGroupByArgs<T>;
        Update: UserMediaSharePermissionsUpdateArgs<T>;
        UpdateMany: UserMediaSharePermissionsUpdateManyArgs<T>;
        UpdateManyAndReturn: UserMediaSharePermissionsUpdateManyAndReturnArgs<T>;
        Upsert: UserMediaSharePermissionsUpsertArgs<T>;
    };
    UserMediaShareSettings: {
        Aggregate: UserMediaShareSettingsAggregateArgs<T>;
        Count: UserMediaShareSettingsCountArgs<T>;
        Create: UserMediaShareSettingsCreateArgs<T>;
        CreateMany: UserMediaShareSettingsCreateManyArgs<T>;
        CreateManyAndReturn: UserMediaShareSettingsCreateManyAndReturnArgs<T>;
        Default: UserMediaShareSettingsDefaultArgs<T>;
        Delete: UserMediaShareSettingsDeleteArgs<T>;
        DeleteMany: UserMediaShareSettingsDeleteManyArgs<T>;
        FindFirst: UserMediaShareSettingsFindFirstArgs<T>;
        FindFirstOrThrow: UserMediaShareSettingsFindFirstOrThrowArgs<T>;
        FindMany: UserMediaShareSettingsFindManyArgs<T>;
        FindUnique: UserMediaShareSettingsFindUniqueArgs<T>;
        FindUniqueOrThrow: UserMediaShareSettingsFindUniqueOrThrowArgs<T>;
        GroupBy: UserMediaShareSettingsGroupByArgs<T>;
        Update: UserMediaShareSettingsUpdateArgs<T>;
        UpdateMany: UserMediaShareSettingsUpdateManyArgs<T>;
        UpdateManyAndReturn: UserMediaShareSettingsUpdateManyAndReturnArgs<T>;
        Upsert: UserMediaShareSettingsUpsertArgs<T>;
    };
    UserNotificationData: {
        Aggregate: UserNotificationDataAggregateArgs<T>;
        Count: UserNotificationDataCountArgs<T>;
        Create: UserNotificationDataCreateArgs<T>;
        CreateMany: UserNotificationDataCreateManyArgs<T>;
        CreateManyAndReturn: UserNotificationDataCreateManyAndReturnArgs<T>;
        Default: UserNotificationDataDefaultArgs<T>;
        Delete: UserNotificationDataDeleteArgs<T>;
        DeleteMany: UserNotificationDataDeleteManyArgs<T>;
        FindFirst: UserNotificationDataFindFirstArgs<T>;
        FindFirstOrThrow: UserNotificationDataFindFirstOrThrowArgs<T>;
        FindMany: UserNotificationDataFindManyArgs<T>;
        FindUnique: UserNotificationDataFindUniqueArgs<T>;
        FindUniqueOrThrow: UserNotificationDataFindUniqueOrThrowArgs<T>;
        GroupBy: UserNotificationDataGroupByArgs<T>;
        Update: UserNotificationDataUpdateArgs<T>;
        UpdateMany: UserNotificationDataUpdateManyArgs<T>;
        UpdateManyAndReturn: UserNotificationDataUpdateManyAndReturnArgs<T>;
        Upsert: UserNotificationDataUpsertArgs<T>;
    };
    UserNotifications: {
        Aggregate: UserNotificationsAggregateArgs<T>;
        Count: UserNotificationsCountArgs<T>;
        Create: UserNotificationsCreateArgs<T>;
        CreateMany: UserNotificationsCreateManyArgs<T>;
        CreateManyAndReturn: UserNotificationsCreateManyAndReturnArgs<T>;
        Default: UserNotificationsDefaultArgs<T>;
        Delete: UserNotificationsDeleteArgs<T>;
        DeleteMany: UserNotificationsDeleteManyArgs<T>;
        FindFirst: UserNotificationsFindFirstArgs<T>;
        FindFirstOrThrow: UserNotificationsFindFirstOrThrowArgs<T>;
        FindMany: UserNotificationsFindManyArgs<T>;
        FindUnique: UserNotificationsFindUniqueArgs<T>;
        FindUniqueOrThrow: UserNotificationsFindUniqueOrThrowArgs<T>;
        GroupBy: UserNotificationsGroupByArgs<T>;
        Update: UserNotificationsUpdateArgs<T>;
        UpdateMany: UserNotificationsUpdateManyArgs<T>;
        UpdateManyAndReturn: UserNotificationsUpdateManyAndReturnArgs<T>;
        Upsert: UserNotificationsUpsertArgs<T>;
    };
    UserPremium: {
        Aggregate: UserPremiumAggregateArgs<T>;
        Count: UserPremiumCountArgs<T>;
        Create: UserPremiumCreateArgs<T>;
        CreateMany: UserPremiumCreateManyArgs<T>;
        CreateManyAndReturn: UserPremiumCreateManyAndReturnArgs<T>;
        Default: UserPremiumDefaultArgs<T>;
        Delete: UserPremiumDeleteArgs<T>;
        DeleteMany: UserPremiumDeleteManyArgs<T>;
        FindFirst: UserPremiumFindFirstArgs<T>;
        FindFirstOrThrow: UserPremiumFindFirstOrThrowArgs<T>;
        FindMany: UserPremiumFindManyArgs<T>;
        FindUnique: UserPremiumFindUniqueArgs<T>;
        FindUniqueOrThrow: UserPremiumFindUniqueOrThrowArgs<T>;
        GroupBy: UserPremiumGroupByArgs<T>;
        Update: UserPremiumUpdateArgs<T>;
        UpdateMany: UserPremiumUpdateManyArgs<T>;
        UpdateManyAndReturn: UserPremiumUpdateManyAndReturnArgs<T>;
        Upsert: UserPremiumUpsertArgs<T>;
    };
    UserRumbleAccount: {
        Aggregate: UserRumbleAccountAggregateArgs<T>;
        Count: UserRumbleAccountCountArgs<T>;
        Create: UserRumbleAccountCreateArgs<T>;
        CreateMany: UserRumbleAccountCreateManyArgs<T>;
        CreateManyAndReturn: UserRumbleAccountCreateManyAndReturnArgs<T>;
        Default: UserRumbleAccountDefaultArgs<T>;
        Delete: UserRumbleAccountDeleteArgs<T>;
        DeleteMany: UserRumbleAccountDeleteManyArgs<T>;
        FindFirst: UserRumbleAccountFindFirstArgs<T>;
        FindFirstOrThrow: UserRumbleAccountFindFirstOrThrowArgs<T>;
        FindMany: UserRumbleAccountFindManyArgs<T>;
        FindUnique: UserRumbleAccountFindUniqueArgs<T>;
        FindUniqueOrThrow: UserRumbleAccountFindUniqueOrThrowArgs<T>;
        GroupBy: UserRumbleAccountGroupByArgs<T>;
        Update: UserRumbleAccountUpdateArgs<T>;
        UpdateMany: UserRumbleAccountUpdateManyArgs<T>;
        UpdateManyAndReturn: UserRumbleAccountUpdateManyAndReturnArgs<T>;
        Upsert: UserRumbleAccountUpsertArgs<T>;
    };
    UserSession: {
        Aggregate: UserSessionAggregateArgs<T>;
        Count: UserSessionCountArgs<T>;
        Create: UserSessionCreateArgs<T>;
        CreateMany: UserSessionCreateManyArgs<T>;
        CreateManyAndReturn: UserSessionCreateManyAndReturnArgs<T>;
        Default: UserSessionDefaultArgs<T>;
        Delete: UserSessionDeleteArgs<T>;
        DeleteMany: UserSessionDeleteManyArgs<T>;
        FindFirst: UserSessionFindFirstArgs<T>;
        FindFirstOrThrow: UserSessionFindFirstOrThrowArgs<T>;
        FindMany: UserSessionFindManyArgs<T>;
        FindUnique: UserSessionFindUniqueArgs<T>;
        FindUniqueOrThrow: UserSessionFindUniqueOrThrowArgs<T>;
        GroupBy: UserSessionGroupByArgs<T>;
        Update: UserSessionUpdateArgs<T>;
        UpdateMany: UserSessionUpdateManyArgs<T>;
        UpdateManyAndReturn: UserSessionUpdateManyAndReturnArgs<T>;
        Upsert: UserSessionUpsertArgs<T>;
    };
    UserTwitchAccount: {
        Aggregate: UserTwitchAccountAggregateArgs<T>;
        Count: UserTwitchAccountCountArgs<T>;
        Create: UserTwitchAccountCreateArgs<T>;
        CreateMany: UserTwitchAccountCreateManyArgs<T>;
        CreateManyAndReturn: UserTwitchAccountCreateManyAndReturnArgs<T>;
        Default: UserTwitchAccountDefaultArgs<T>;
        Delete: UserTwitchAccountDeleteArgs<T>;
        DeleteMany: UserTwitchAccountDeleteManyArgs<T>;
        FindFirst: UserTwitchAccountFindFirstArgs<T>;
        FindFirstOrThrow: UserTwitchAccountFindFirstOrThrowArgs<T>;
        FindMany: UserTwitchAccountFindManyArgs<T>;
        FindUnique: UserTwitchAccountFindUniqueArgs<T>;
        FindUniqueOrThrow: UserTwitchAccountFindUniqueOrThrowArgs<T>;
        GroupBy: UserTwitchAccountGroupByArgs<T>;
        Update: UserTwitchAccountUpdateArgs<T>;
        UpdateMany: UserTwitchAccountUpdateManyArgs<T>;
        UpdateManyAndReturn: UserTwitchAccountUpdateManyAndReturnArgs<T>;
        Upsert: UserTwitchAccountUpsertArgs<T>;
    };
    YTSCurrentlyLive: {
        Aggregate: YTSCurrentlyLiveAggregateArgs<T>;
        Count: YTSCurrentlyLiveCountArgs<T>;
        Create: YTSCurrentlyLiveCreateArgs<T>;
        CreateMany: YTSCurrentlyLiveCreateManyArgs<T>;
        CreateManyAndReturn: YTSCurrentlyLiveCreateManyAndReturnArgs<T>;
        Default: YTSCurrentlyLiveDefaultArgs<T>;
        Delete: YTSCurrentlyLiveDeleteArgs<T>;
        DeleteMany: YTSCurrentlyLiveDeleteManyArgs<T>;
        FindFirst: YTSCurrentlyLiveFindFirstArgs<T>;
        FindFirstOrThrow: YTSCurrentlyLiveFindFirstOrThrowArgs<T>;
        FindMany: YTSCurrentlyLiveFindManyArgs<T>;
        FindUnique: YTSCurrentlyLiveFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSCurrentlyLiveFindUniqueOrThrowArgs<T>;
        GroupBy: YTSCurrentlyLiveGroupByArgs<T>;
        Update: YTSCurrentlyLiveUpdateArgs<T>;
        UpdateMany: YTSCurrentlyLiveUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSCurrentlyLiveUpdateManyAndReturnArgs<T>;
        Upsert: YTSCurrentlyLiveUpsertArgs<T>;
    };
    YTSCustomMessage: {
        Aggregate: YTSCustomMessageAggregateArgs<T>;
        Count: YTSCustomMessageCountArgs<T>;
        Create: YTSCustomMessageCreateArgs<T>;
        CreateMany: YTSCustomMessageCreateManyArgs<T>;
        CreateManyAndReturn: YTSCustomMessageCreateManyAndReturnArgs<T>;
        Default: YTSCustomMessageDefaultArgs<T>;
        Delete: YTSCustomMessageDeleteArgs<T>;
        DeleteMany: YTSCustomMessageDeleteManyArgs<T>;
        FindFirst: YTSCustomMessageFindFirstArgs<T>;
        FindFirstOrThrow: YTSCustomMessageFindFirstOrThrowArgs<T>;
        FindMany: YTSCustomMessageFindManyArgs<T>;
        FindUnique: YTSCustomMessageFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSCustomMessageFindUniqueOrThrowArgs<T>;
        GroupBy: YTSCustomMessageGroupByArgs<T>;
        Update: YTSCustomMessageUpdateArgs<T>;
        UpdateMany: YTSCustomMessageUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSCustomMessageUpdateManyAndReturnArgs<T>;
        Upsert: YTSCustomMessageUpsertArgs<T>;
    };
    YTSEmbedField: {
        Aggregate: YTSEmbedFieldAggregateArgs<T>;
        Count: YTSEmbedFieldCountArgs<T>;
        Create: YTSEmbedFieldCreateArgs<T>;
        CreateMany: YTSEmbedFieldCreateManyArgs<T>;
        CreateManyAndReturn: YTSEmbedFieldCreateManyAndReturnArgs<T>;
        Default: YTSEmbedFieldDefaultArgs<T>;
        Delete: YTSEmbedFieldDeleteArgs<T>;
        DeleteMany: YTSEmbedFieldDeleteManyArgs<T>;
        FindFirst: YTSEmbedFieldFindFirstArgs<T>;
        FindFirstOrThrow: YTSEmbedFieldFindFirstOrThrowArgs<T>;
        FindMany: YTSEmbedFieldFindManyArgs<T>;
        FindUnique: YTSEmbedFieldFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSEmbedFieldFindUniqueOrThrowArgs<T>;
        GroupBy: YTSEmbedFieldGroupByArgs<T>;
        Update: YTSEmbedFieldUpdateArgs<T>;
        UpdateMany: YTSEmbedFieldUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSEmbedFieldUpdateManyAndReturnArgs<T>;
        Upsert: YTSEmbedFieldUpsertArgs<T>;
    };
    YTSMessageButton: {
        Aggregate: YTSMessageButtonAggregateArgs<T>;
        Count: YTSMessageButtonCountArgs<T>;
        Create: YTSMessageButtonCreateArgs<T>;
        CreateMany: YTSMessageButtonCreateManyArgs<T>;
        CreateManyAndReturn: YTSMessageButtonCreateManyAndReturnArgs<T>;
        Default: YTSMessageButtonDefaultArgs<T>;
        Delete: YTSMessageButtonDeleteArgs<T>;
        DeleteMany: YTSMessageButtonDeleteManyArgs<T>;
        FindFirst: YTSMessageButtonFindFirstArgs<T>;
        FindFirstOrThrow: YTSMessageButtonFindFirstOrThrowArgs<T>;
        FindMany: YTSMessageButtonFindManyArgs<T>;
        FindUnique: YTSMessageButtonFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSMessageButtonFindUniqueOrThrowArgs<T>;
        GroupBy: YTSMessageButtonGroupByArgs<T>;
        Update: YTSMessageButtonUpdateArgs<T>;
        UpdateMany: YTSMessageButtonUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSMessageButtonUpdateManyAndReturnArgs<T>;
        Upsert: YTSMessageButtonUpsertArgs<T>;
    };
    YTSMessageEmbed: {
        Aggregate: YTSMessageEmbedAggregateArgs<T>;
        Count: YTSMessageEmbedCountArgs<T>;
        Create: YTSMessageEmbedCreateArgs<T>;
        CreateMany: YTSMessageEmbedCreateManyArgs<T>;
        CreateManyAndReturn: YTSMessageEmbedCreateManyAndReturnArgs<T>;
        Default: YTSMessageEmbedDefaultArgs<T>;
        Delete: YTSMessageEmbedDeleteArgs<T>;
        DeleteMany: YTSMessageEmbedDeleteManyArgs<T>;
        FindFirst: YTSMessageEmbedFindFirstArgs<T>;
        FindFirstOrThrow: YTSMessageEmbedFindFirstOrThrowArgs<T>;
        FindMany: YTSMessageEmbedFindManyArgs<T>;
        FindUnique: YTSMessageEmbedFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSMessageEmbedFindUniqueOrThrowArgs<T>;
        GroupBy: YTSMessageEmbedGroupByArgs<T>;
        Update: YTSMessageEmbedUpdateArgs<T>;
        UpdateMany: YTSMessageEmbedUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSMessageEmbedUpdateManyAndReturnArgs<T>;
        Upsert: YTSMessageEmbedUpsertArgs<T>;
    };
    YTSMessageWebhook: {
        Aggregate: YTSMessageWebhookAggregateArgs<T>;
        Count: YTSMessageWebhookCountArgs<T>;
        Create: YTSMessageWebhookCreateArgs<T>;
        CreateMany: YTSMessageWebhookCreateManyArgs<T>;
        CreateManyAndReturn: YTSMessageWebhookCreateManyAndReturnArgs<T>;
        Default: YTSMessageWebhookDefaultArgs<T>;
        Delete: YTSMessageWebhookDeleteArgs<T>;
        DeleteMany: YTSMessageWebhookDeleteManyArgs<T>;
        FindFirst: YTSMessageWebhookFindFirstArgs<T>;
        FindFirstOrThrow: YTSMessageWebhookFindFirstOrThrowArgs<T>;
        FindMany: YTSMessageWebhookFindManyArgs<T>;
        FindUnique: YTSMessageWebhookFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSMessageWebhookFindUniqueOrThrowArgs<T>;
        GroupBy: YTSMessageWebhookGroupByArgs<T>;
        Update: YTSMessageWebhookUpdateArgs<T>;
        UpdateMany: YTSMessageWebhookUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSMessageWebhookUpdateManyAndReturnArgs<T>;
        Upsert: YTSMessageWebhookUpsertArgs<T>;
    };
    YTSStatsChannelId: {
        Aggregate: YTSStatsChannelIdAggregateArgs<T>;
        Count: YTSStatsChannelIdCountArgs<T>;
        Create: YTSStatsChannelIdCreateArgs<T>;
        CreateMany: YTSStatsChannelIdCreateManyArgs<T>;
        CreateManyAndReturn: YTSStatsChannelIdCreateManyAndReturnArgs<T>;
        Default: YTSStatsChannelIdDefaultArgs<T>;
        Delete: YTSStatsChannelIdDeleteArgs<T>;
        DeleteMany: YTSStatsChannelIdDeleteManyArgs<T>;
        FindFirst: YTSStatsChannelIdFindFirstArgs<T>;
        FindFirstOrThrow: YTSStatsChannelIdFindFirstOrThrowArgs<T>;
        FindMany: YTSStatsChannelIdFindManyArgs<T>;
        FindUnique: YTSStatsChannelIdFindUniqueArgs<T>;
        FindUniqueOrThrow: YTSStatsChannelIdFindUniqueOrThrowArgs<T>;
        GroupBy: YTSStatsChannelIdGroupByArgs<T>;
        Update: YTSStatsChannelIdUpdateArgs<T>;
        UpdateMany: YTSStatsChannelIdUpdateManyArgs<T>;
        UpdateManyAndReturn: YTSStatsChannelIdUpdateManyAndReturnArgs<T>;
        Upsert: YTSStatsChannelIdUpsertArgs<T>;
    };
    YoutubeStreamer: {
        Aggregate: YoutubeStreamerAggregateArgs<T>;
        Count: YoutubeStreamerCountArgs<T>;
        Create: YoutubeStreamerCreateArgs<T>;
        CreateMany: YoutubeStreamerCreateManyArgs<T>;
        CreateManyAndReturn: YoutubeStreamerCreateManyAndReturnArgs<T>;
        Default: YoutubeStreamerDefaultArgs<T>;
        Delete: YoutubeStreamerDeleteArgs<T>;
        DeleteMany: YoutubeStreamerDeleteManyArgs<T>;
        FindFirst: YoutubeStreamerFindFirstArgs<T>;
        FindFirstOrThrow: YoutubeStreamerFindFirstOrThrowArgs<T>;
        FindMany: YoutubeStreamerFindManyArgs<T>;
        FindUnique: YoutubeStreamerFindUniqueArgs<T>;
        FindUniqueOrThrow: YoutubeStreamerFindUniqueOrThrowArgs<T>;
        GroupBy: YoutubeStreamerGroupByArgs<T>;
        Update: YoutubeStreamerUpdateArgs<T>;
        UpdateMany: YoutubeStreamerUpdateManyArgs<T>;
        UpdateManyAndReturn: YoutubeStreamerUpdateManyAndReturnArgs<T>;
        Upsert: YoutubeStreamerUpsertArgs<T>;
    };
}

Type Parameters

T extends DefaultArgs = DefaultArgs