@devvit/protos 0.10.23-next-2024-07-23-5e7d46268.0 → 0.10.23-next-2024-07-24-282f4c343.0

package/schema/devvit/actor/automation/v1alpha/event_handlers.proto

@@ -87,3 +87,11 @@ service OnModMail {
 service OnAccountDelete {
   rpc OnAccountDelete(devvit.events.v1alpha.AccountDelete) returns (HandlerResult);
 }
+
+service OnPostNsfwUpdate {
+  rpc OnPostNsfwUpdate(devvit.events.v1alpha.PostNsfwUpdate) returns (HandlerResult);
+}
+
+service OnPostSpoilerUpdate {
+  rpc OnPostSpoilerUpdate(devvit.events.v1alpha.PostSpoilerUpdate) returns (HandlerResult);
+}

package/schema/devvit/data/triggers/v1alpha/triggers.proto

@@ -141,7 +141,13 @@ message TriggerEvent {
       },
       (devvit.options.firehose_event_type) = COMMENT_APPROVE
     ];
+    devvit.events.v1alpha.PostNsfwUpdate nsfw_post_update = 120 [(devvit.options.deliver_to) = {
+      to: [GATEWAY]
+    }];
 
-    // NEXT: 120
+    devvit.events.v1alpha.PostSpoilerUpdate spoiler_post_update = 121 [(devvit.options.deliver_to) = {
+      to: [GATEWAY]
+    }];
+    // NEXT: 122
   }
 }

package/schema/devvit/events/v1alpha/events.proto

@@ -350,3 +350,60 @@ message Vote {
   reserved 1 to 3;
   reserved "thing_id", "upvotes", "downvotes";
 }
+
+message PostNsfwUpdate {
+  option (devvit.options.trigger) = {
+    source: "moderator"
+    action: "mark_nsfw"
+    noun: "post"
+  };
+  option (devvit.options.trigger) = {
+    source: "moderator"
+    action: "marknsfw"
+    noun: "post"
+  };
+  option (devvit.options.trigger) = {
+    source: "automoderator"
+    action: "mark_nsfw"
+    noun: "post"
+  };
+  option (devvit.options.trigger) = {
+    source: "automoderator"
+    action: "unmark_nsfw"
+    noun: "post"
+  };
+
+  devvit.reddit.v2alpha.PostV2 post = 1;
+  devvit.reddit.v2alpha.UserV2 author = 2;
+  bool is_nsfw = 3 [(devvit.options.v2_event_path) = "target_post.nsfw"];
+
+  devvit.reddit.v2alpha.SubredditV2 subreddit = 10 [(devvit.options.secondary_hydration_path) = "post.subreddit_id"];
+}
+
+message PostSpoilerUpdate {
+  option (devvit.options.trigger) = {
+    source: "moderator"
+    action: "mark_spoiler"
+    noun: "post"
+  };
+  option (devvit.options.trigger) = {
+    source: "moderator"
+    action: "unmark_spoiler"
+    noun: "post"
+  };
+  option (devvit.options.trigger) = {
+    source: "automoderator"
+    action: "mark_spoiler"
+    noun: "post"
+  };
+  option (devvit.options.trigger) = {
+    source: "automoderator"
+    action: "unmark_spoiler"
+    noun: "post"
+  };
+  devvit.reddit.v2alpha.PostV2 post = 1;
+  devvit.reddit.v2alpha.UserV2 author = 2;
+  bool is_spoiler = 4 [(devvit.options.v2_event_path) = "target_post.spoiler"];
+
+  devvit.reddit.v2alpha.SubredditV2 subreddit = 10 [(devvit.options.secondary_hydration_path) = "post.subreddit_id"];
+}

package/types/devvit/actor/automation/v1alpha/event_handlers.d.ts

@@ -5,7 +5,7 @@
  */
 import _m0 from 'protobufjs/minimal.js';
 import { Metadata } from "../../../../../lib/Types.js";
-import { AccountDelete, AppInstall, AppUpgrade, CommentApprove, CommentCreate, CommentDelete, CommentReport, CommentSubmit, CommentUpdate, PostApprove, PostCreate, PostDelete, PostFlairUpdate, PostReport, PostSubmit, PostUpdate, SubredditSubscribe } from '../../../events/v1alpha/events.js';
+import { AccountDelete, AppInstall, AppUpgrade, CommentApprove, CommentCreate, CommentDelete, CommentReport, CommentSubmit, CommentUpdate, PostApprove, PostCreate, PostDelete, PostFlairUpdate, PostNsfwUpdate, PostReport, PostSpoilerUpdate, PostSubmit, PostUpdate, SubredditSubscribe } from '../../../events/v1alpha/events.js';
 import { ModAction } from '../../../reddit/v2alpha/modaction.js';
 import { ModMail } from '../../../reddit/v2alpha/modmail.js';
 /** This needs to rectified with StepResult at some point */
@@ -4349,6 +4349,584 @@ export declare const OnAccountDeleteDefinition: {
         };
     };
 };
+export interface OnPostNsfwUpdate {
+    OnPostNsfwUpdate(request: PostNsfwUpdate, metadata?: Metadata): Promise<HandlerResult>;
+}
+export declare const OnPostNsfwUpdateServiceName = "devvit.actor.automation.v1alpha.OnPostNsfwUpdate";
+export declare class OnPostNsfwUpdateClientImpl implements OnPostNsfwUpdate {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
+    OnPostNsfwUpdate(request: PostNsfwUpdate, metadata?: Metadata): Promise<HandlerResult>;
+}
+export type OnPostNsfwUpdateDefinition = typeof OnPostNsfwUpdateDefinition;
+export declare const OnPostNsfwUpdateDefinition: {
+    readonly name: "OnPostNsfwUpdate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostNsfwUpdate";
+    readonly methods: {
+        readonly onPostNsfwUpdate: {
+            readonly name: "OnPostNsfwUpdate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostNsfwUpdate";
+                encode(message: PostNsfwUpdate, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostNsfwUpdate;
+                fromJSON(object: any): PostNsfwUpdate;
+                toJSON(message: PostNsfwUpdate): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    isNsfw?: boolean;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostNsfwUpdate;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    isNsfw?: boolean;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostNsfwUpdate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface OnPostSpoilerUpdate {
+    OnPostSpoilerUpdate(request: PostSpoilerUpdate, metadata?: Metadata): Promise<HandlerResult>;
+}
+export declare const OnPostSpoilerUpdateServiceName = "devvit.actor.automation.v1alpha.OnPostSpoilerUpdate";
+export declare class OnPostSpoilerUpdateClientImpl implements OnPostSpoilerUpdate {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
+    OnPostSpoilerUpdate(request: PostSpoilerUpdate, metadata?: Metadata): Promise<HandlerResult>;
+}
+export type OnPostSpoilerUpdateDefinition = typeof OnPostSpoilerUpdateDefinition;
+export declare const OnPostSpoilerUpdateDefinition: {
+    readonly name: "OnPostSpoilerUpdate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostSpoilerUpdate";
+    readonly methods: {
+        readonly onPostSpoilerUpdate: {
+            readonly name: "OnPostSpoilerUpdate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostSpoilerUpdate";
+                encode(message: PostSpoilerUpdate, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostSpoilerUpdate;
+                fromJSON(object: any): PostSpoilerUpdate;
+                toJSON(message: PostSpoilerUpdate): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    isSpoiler?: boolean;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostSpoilerUpdate;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    isSpoiler?: boolean;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostSpoilerUpdate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
 interface Rpc {
     request(service: string, method: string, data: Uint8Array, metadata?: Metadata): Promise<Uint8Array>;
 }