@devvit/public-api 0.10.23-next-2024-07-23-5e7d46268.0 → 0.10.23-next-2024-07-30-8bdb131a7.0

package/public-api.d.ts

@@ -347,7 +347,7 @@ declare abstract class Actor {
 }
 
 /** Any Known Actor Definitions */
-declare type ActorDefinition = AppSettingsDefinition | AssetResolverDefinition | BotDefinition | BuildPackDefinition | BuilderDefinition | BundleServiceDefinition | CacheUtilsDefinition | ClockDefinition | ContextActionDefinition | CustomActionsDefinition | CustomPostDefinition | CustomPostSnapshotResolverDefinition | DataApiAuthTokenIssuerDefinition | DataIntakerDefinition | DevvitProfilerDefinition | EnvelopeReceiverPortDefinition | FlairDefinition | GraphQLDefinition | HTTPDefinition | HelloDefinition | InspectorDefinition | InstallationSettingsDefinition | InstanceSettingsDefinition | KVStoreDefinition | LinkerDefinition | LinksAndCommentsDefinition | ListingsDefinition | LoggerDefinition | MediaServiceDefinition | ModInviteUtilsDefinition | ModNoteDefinition | ModerationDefinition | ModlogDefinition | NewModmailDefinition | OnAccountDeleteDefinition | OnAppInstallDefinition | OnAppUpgradeDefinition | OnCommentApproveDefinition | OnCommentCreateDefinition | OnCommentDeleteDefinition | OnCommentReportDefinition | OnCommentSubmitDefinition | OnCommentUpdateDefinition | OnModActionDefinition | OnModMailDefinition | OnPostApproveDefinition | OnPostCreateDefinition | OnPostDeleteDefinition | OnPostFlairUpdateDefinition | OnPostReportDefinition | OnPostSubmitDefinition | OnPostUpdateDefinition | OnSubredditSubscribeDefinition | PostCollectionsDefinition | PostFilterDefinition | PrivateMessagesDefinition | ProducerDefinition | RealtimeDefinition | RedditAPIV2Definition | RedisAPIDefinition | RemoteLogConsumerDefinition | RemoteLogPublisherDefinition | ResolverDefinition | SchedulerDefinition | SchedulerHandlerDefinition | SettingsDefinition | StreamBrokerDefinition | StreamsDefinition | SubredditMetadataResolverDefinition | SubredditsDefinition | TimerDefinition | TriggersDefinition | UIEventHandlerDefinition | UserConfigurableDefinition | UsersDefinition | V2EventsDefinition | WidgetsDefinition | WikiDefinition | WrapperTypesDefinition;
+declare type ActorDefinition = AppSettingsDefinition | AssetResolverDefinition | BotDefinition | BuildPackDefinition | BuilderDefinition | BundleServiceDefinition | CacheUtilsDefinition | ClockDefinition | ContextActionDefinition | CustomActionsDefinition | CustomPostDefinition | CustomPostSnapshotResolverDefinition | DataApiAuthTokenIssuerDefinition | DataIntakerDefinition | DevvitProfilerDefinition | EnvelopeReceiverPortDefinition | FlairDefinition | GraphQLDefinition | HTTPDefinition | HelloDefinition | InspectorDefinition | InstallationSettingsDefinition | InstanceSettingsDefinition | KVStoreDefinition | LinkerDefinition | LinksAndCommentsDefinition | ListingsDefinition | LoggerDefinition | MediaServiceDefinition | ModInviteUtilsDefinition | ModNoteDefinition | ModerationDefinition | ModlogDefinition | NewModmailDefinition | OnAccountDeleteDefinition | OnAppInstallDefinition | OnAppUpgradeDefinition | OnCommentApproveDefinition | OnCommentCreateDefinition | OnCommentDeleteDefinition | OnCommentReportDefinition | OnCommentSubmitDefinition | OnCommentUpdateDefinition | OnModActionDefinition | OnModMailDefinition | OnPostApproveDefinition | OnPostCreateDefinition | OnPostDeleteDefinition | OnPostFlairUpdateDefinition | OnPostReportDefinition | OnPostSubmitDefinition | OnPostUpdateDefinition | OnPostNsfwUpdateDefinition | OnPostSpoilerUpdateDefinition | OnSubredditSubscribeDefinition | PostCollectionsDefinition | PostFilterDefinition | PrivateMessagesDefinition | ProducerDefinition | RealtimeDefinition | RedditAPIV2Definition | RedisAPIDefinition | RemoteLogConsumerDefinition | RemoteLogPublisherDefinition | ResolverDefinition | SchedulerDefinition | SchedulerHandlerDefinition | SettingsDefinition | StreamBrokerDefinition | StreamsDefinition | SubredditMetadataResolverDefinition | SubredditsDefinition | TimerDefinition | TriggersDefinition | UIEventHandlerDefinition | UserConfigurableDefinition | UsersDefinition | V2EventsDefinition | WidgetsDefinition | WikiDefinition | WrapperTypesDefinition;
 
 /** Map from any known actor name to their client. */
 declare type ActorNameClientMap = {
@@ -400,6 +400,8 @@ declare type ActorNameClientMap = {
     OnPostCreate: OnPostCreate;
     OnPostDelete: OnPostDelete;
     OnPostFlairUpdate: OnPostFlairUpdate;
+    OnPostNsfwUpdate: OnPostNsfwUpdate;
+    OnPostSpoilerUpdate: OnPostSpoilerUpdate;
     OnPostReport: OnPostReport;
     OnPostSubmit: OnPostSubmit;
     OnPostUpdate: OnPostUpdate;
@@ -37733,33 +37735,33 @@ declare const OnPostFlairUpdateDefinition: {
 
 declare const OnPostFlairUpdateServiceName = "devvit.actor.automation.v1alpha.OnPostFlairUpdate";
 
-declare interface OnPostReport {
-    OnPostReport(request: PostReport_2, metadata?: Metadata): Promise<HandlerResult>;
+declare interface OnPostNsfwUpdate {
+    OnPostNsfwUpdate(request: PostNsfwUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
 }
 
-declare class OnPostReportClientImpl implements OnPostReport {
+declare class OnPostNsfwUpdateClientImpl implements OnPostNsfwUpdate {
     private readonly rpc;
     private readonly service;
     constructor(rpc: Rpc_68, opts?: {
         service?: string;
     });
-    OnPostReport(request: PostReport_2, metadata?: Metadata): Promise<HandlerResult>;
+    OnPostNsfwUpdate(request: PostNsfwUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
 }
 
-declare type OnPostReportDefinition = typeof OnPostReportDefinition;
+declare type OnPostNsfwUpdateDefinition = typeof OnPostNsfwUpdateDefinition;
 
-declare const OnPostReportDefinition: {
-    readonly name: "OnPostReport";
-    readonly fullName: "devvit.actor.automation.v1alpha.OnPostReport";
+declare const OnPostNsfwUpdateDefinition: {
+    readonly name: "OnPostNsfwUpdate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostNsfwUpdate";
     readonly methods: {
-        readonly onPostReport: {
-            readonly name: "OnPostReport";
+        readonly onPostNsfwUpdate: {
+            readonly name: "OnPostNsfwUpdate";
             readonly requestType: {
-                $type: "devvit.events.v1alpha.PostReport";
-                encode(message: PostReport_2, writer?: _m0.Writer): _m0.Writer;
-                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostReport_2;
-                fromJSON(object: any): PostReport_2;
-                toJSON(message: PostReport_2): unknown;
+                $type: "devvit.events.v1alpha.PostNsfwUpdate";
+                encode(message: PostNsfwUpdate_2, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostNsfwUpdate_2;
+                fromJSON(object: any): PostNsfwUpdate_2;
+                toJSON(message: PostNsfwUpdate_2): unknown;
                 create(base?: {
                     post?: {
                         id?: string;
@@ -37849,6 +37851,28 @@ declare const OnPostReportDefinition: {
                         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;
@@ -37861,8 +37885,7 @@ declare const OnPostReportDefinition: {
                         subscribersCount?: number;
                         permalink?: string;
                     } | undefined;
-                    reason?: string;
-                } | undefined): PostReport_2;
+                } | undefined): PostNsfwUpdate_2;
                 fromPartial(object: {
                     post?: {
                         id?: string;
@@ -37952,6 +37975,28 @@ declare const OnPostReportDefinition: {
                         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;
@@ -37964,8 +38009,7 @@ declare const OnPostReportDefinition: {
                         subscribersCount?: number;
                         permalink?: string;
                     } | undefined;
-                    reason?: string;
-                }): PostReport_2;
+                }): PostNsfwUpdate_2;
             };
             readonly requestStream: false;
             readonly responseType: {
@@ -37983,35 +38027,35 @@ declare const OnPostReportDefinition: {
     };
 };
 
-declare const OnPostReportServiceName = "devvit.actor.automation.v1alpha.OnPostReport";
+declare const OnPostNsfwUpdateServiceName = "devvit.actor.automation.v1alpha.OnPostNsfwUpdate";
 
-declare interface OnPostSubmit {
-    OnPostSubmit(request: PostSubmit_2, metadata?: Metadata): Promise<HandlerResult>;
+declare interface OnPostReport {
+    OnPostReport(request: PostReport_2, metadata?: Metadata): Promise<HandlerResult>;
 }
 
-declare class OnPostSubmitClientImpl implements OnPostSubmit {
+declare class OnPostReportClientImpl implements OnPostReport {
     private readonly rpc;
     private readonly service;
     constructor(rpc: Rpc_68, opts?: {
         service?: string;
     });
-    OnPostSubmit(request: PostSubmit_2, metadata?: Metadata): Promise<HandlerResult>;
+    OnPostReport(request: PostReport_2, metadata?: Metadata): Promise<HandlerResult>;
 }
 
-declare type OnPostSubmitDefinition = typeof OnPostSubmitDefinition;
+declare type OnPostReportDefinition = typeof OnPostReportDefinition;
 
-declare const OnPostSubmitDefinition: {
-    readonly name: "OnPostSubmit";
-    readonly fullName: "devvit.actor.automation.v1alpha.OnPostSubmit";
+declare const OnPostReportDefinition: {
+    readonly name: "OnPostReport";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostReport";
     readonly methods: {
-        readonly onPostSubmit: {
-            readonly name: "OnPostSubmit";
+        readonly onPostReport: {
+            readonly name: "OnPostReport";
             readonly requestType: {
-                $type: "devvit.events.v1alpha.PostSubmit";
-                encode(message: PostSubmit_2, writer?: _m0.Writer): _m0.Writer;
-                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostSubmit_2;
-                fromJSON(object: any): PostSubmit_2;
-                toJSON(message: PostSubmit_2): unknown;
+                $type: "devvit.events.v1alpha.PostReport";
+                encode(message: PostReport_2, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostReport_2;
+                fromJSON(object: any): PostReport_2;
+                toJSON(message: PostReport_2): unknown;
                 create(base?: {
                     post?: {
                         id?: string;
@@ -38101,15 +38145,53 @@ declare const OnPostSubmitDefinition: {
                         type?: string;
                         unlisted?: boolean;
                     } | undefined;
-                    author?: {
+                    subreddit?: {
                         id?: string;
                         name?: string;
-                        isGold?: boolean;
-                        snoovatarImage?: string;
-                        url?: string;
+                        nsfw?: boolean;
+                        type?: SubredditType_3;
                         spam?: boolean;
-                        banned?: boolean;
-                        flair?: {
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: SubredditRating_2;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    reason?: string;
+                } | undefined): PostReport_2;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: CrowdControlLevel_2;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: DistinguishType_2;
+                        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;
@@ -38119,8 +38201,52 @@ declare const OnPostSubmitDefinition: {
                             backgroundColor?: string;
                             enabled?: boolean;
                         } | undefined;
-                        karma?: number;
-                        iconImage?: string;
+                        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;
                     subreddit?: {
                         id?: string;
@@ -38134,8 +38260,55 @@ declare const OnPostSubmitDefinition: {
                         subscribersCount?: number;
                         permalink?: string;
                     } | undefined;
-                } | undefined): PostSubmit_2;
-                fromPartial(object: {
+                    reason?: string;
+                }): PostReport_2;
+            };
+            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_75<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial_75<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+
+declare const OnPostReportServiceName = "devvit.actor.automation.v1alpha.OnPostReport";
+
+declare interface OnPostSpoilerUpdate {
+    OnPostSpoilerUpdate(request: PostSpoilerUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
+}
+
+declare class OnPostSpoilerUpdateClientImpl implements OnPostSpoilerUpdate {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc_68, opts?: {
+        service?: string;
+    });
+    OnPostSpoilerUpdate(request: PostSpoilerUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
+}
+
+declare type OnPostSpoilerUpdateDefinition = typeof OnPostSpoilerUpdateDefinition;
+
+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_2, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostSpoilerUpdate_2;
+                fromJSON(object: any): PostSpoilerUpdate_2;
+                toJSON(message: PostSpoilerUpdate_2): unknown;
+                create(base?: {
                     post?: {
                         id?: string;
                         title?: string;
@@ -38245,6 +38418,7 @@ declare const OnPostSubmitDefinition: {
                         karma?: number;
                         iconImage?: string;
                     } | undefined;
+                    isSpoiler?: boolean;
                     subreddit?: {
                         id?: string;
                         name?: string;
@@ -38257,54 +38431,470 @@ declare const OnPostSubmitDefinition: {
                         subscribersCount?: number;
                         permalink?: string;
                     } | undefined;
-                }): PostSubmit_2;
-            };
-            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_75<HandlerResult>): HandlerResult;
-                fromPartial(_: DeepPartial_75<HandlerResult>): HandlerResult;
-            };
-            readonly responseStream: false;
-            readonly options: {};
-        };
-    };
-};
-
-declare const OnPostSubmitServiceName = "devvit.actor.automation.v1alpha.OnPostSubmit";
-
-declare interface OnPostUpdate {
-    OnPostUpdate(request: PostUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
-}
-
-declare class OnPostUpdateClientImpl implements OnPostUpdate {
-    private readonly rpc;
-    private readonly service;
-    constructor(rpc: Rpc_68, opts?: {
-        service?: string;
-    });
-    OnPostUpdate(request: PostUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
-}
-
-declare type OnPostUpdateDefinition = typeof OnPostUpdateDefinition;
-
-declare const OnPostUpdateDefinition: {
-    readonly name: "OnPostUpdate";
-    readonly fullName: "devvit.actor.automation.v1alpha.OnPostUpdate";
-    readonly methods: {
-        readonly onPostUpdate: {
-            readonly name: "OnPostUpdate";
-            readonly requestType: {
-                $type: "devvit.events.v1alpha.PostUpdate";
-                encode(message: PostUpdate_2, writer?: _m0.Writer): _m0.Writer;
-                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostUpdate_2;
-                fromJSON(object: any): PostUpdate_2;
-                toJSON(message: PostUpdate_2): unknown;
-                create(base?: {
+                } | undefined): PostSpoilerUpdate_2;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: CrowdControlLevel_2;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: DistinguishType_2;
+                        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?: SubredditType_3;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: SubredditRating_2;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostSpoilerUpdate_2;
+            };
+            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_75<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial_75<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+
+declare const OnPostSpoilerUpdateServiceName = "devvit.actor.automation.v1alpha.OnPostSpoilerUpdate";
+
+declare interface OnPostSubmit {
+    OnPostSubmit(request: PostSubmit_2, metadata?: Metadata): Promise<HandlerResult>;
+}
+
+declare class OnPostSubmitClientImpl implements OnPostSubmit {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc_68, opts?: {
+        service?: string;
+    });
+    OnPostSubmit(request: PostSubmit_2, metadata?: Metadata): Promise<HandlerResult>;
+}
+
+declare type OnPostSubmitDefinition = typeof OnPostSubmitDefinition;
+
+declare const OnPostSubmitDefinition: {
+    readonly name: "OnPostSubmit";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostSubmit";
+    readonly methods: {
+        readonly onPostSubmit: {
+            readonly name: "OnPostSubmit";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostSubmit";
+                encode(message: PostSubmit_2, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostSubmit_2;
+                fromJSON(object: any): PostSubmit_2;
+                toJSON(message: PostSubmit_2): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: CrowdControlLevel_2;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: DistinguishType_2;
+                        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;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: SubredditType_3;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: SubredditRating_2;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostSubmit_2;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: CrowdControlLevel_2;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: DistinguishType_2;
+                        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;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: SubredditType_3;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: SubredditRating_2;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostSubmit_2;
+            };
+            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_75<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial_75<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+
+declare const OnPostSubmitServiceName = "devvit.actor.automation.v1alpha.OnPostSubmit";
+
+declare interface OnPostUpdate {
+    OnPostUpdate(request: PostUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
+}
+
+declare class OnPostUpdateClientImpl implements OnPostUpdate {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc_68, opts?: {
+        service?: string;
+    });
+    OnPostUpdate(request: PostUpdate_2, metadata?: Metadata): Promise<HandlerResult>;
+}
+
+declare type OnPostUpdateDefinition = typeof OnPostUpdateDefinition;
+
+declare const OnPostUpdateDefinition: {
+    readonly name: "OnPostUpdate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostUpdate";
+    readonly methods: {
+        readonly onPostUpdate: {
+            readonly name: "OnPostUpdate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostUpdate";
+                encode(message: PostUpdate_2, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostUpdate_2;
+                fromJSON(object: any): PostUpdate_2;
+                toJSON(message: PostUpdate_2): unknown;
+                create(base?: {
                     post?: {
                         id?: string;
                         title?: string;
@@ -38687,7 +39277,7 @@ declare const OnSubredditSubscribeDefinition: {
 
 declare const OnSubredditSubscribeServiceName = "devvit.actor.automation.v1alpha.OnSubredditSubscribe";
 
-export declare type OnTriggerRequest = protos.PostFlairUpdate | protos.PostSubmit | protos.PostCreate | protos.PostUpdate | protos.PostReport | protos.PostDelete | protos.CommentSubmit | protos.CommentCreate | protos.CommentUpdate | protos.CommentReport | protos.CommentDelete | protos.AppInstall | protos.AppUpgrade | protos.ModAction | protos.ModMail;
+export declare type OnTriggerRequest = protos.PostFlairUpdate | protos.PostSubmit | protos.PostCreate | protos.PostUpdate | protos.PostReport | protos.PostDelete | protos.CommentSubmit | protos.CommentCreate | protos.CommentUpdate | protos.CommentReport | protos.CommentDelete | protos.AppInstall | protos.AppUpgrade | protos.ModAction | protos.ModMail | protos.PostNsfwUpdate | protos.PostSpoilerUpdate;
 
 export declare type OnValidateHandler<ValueType> = (event: SettingsFormFieldValidatorEvent<ValueType>, context: Devvit.Context) => void | string | Promise<void | string>;
 
@@ -40154,6 +40744,31 @@ declare const PostNotesRequest: {
     fromPartial(object: DeepPartial_3<PostNotesRequest>): PostNotesRequest;
 };
 
+/** The event name for when a post is marked/unmarked as nsfw*/
+export declare type PostNsfwUpdate = 'PostNsfwUpdate';
+
+declare interface PostNsfwUpdate_2 {
+    post?: PostV2 | undefined;
+    author?: UserV2 | undefined;
+    isNsfw: boolean;
+    subreddit?: SubredditV2 | undefined;
+}
+
+declare const PostNsfwUpdate_2: {
+    $type: "devvit.events.v1alpha.PostNsfwUpdate";
+    encode(message: PostNsfwUpdate_2, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PostNsfwUpdate_2;
+    fromJSON(object: any): PostNsfwUpdate_2;
+    toJSON(message: PostNsfwUpdate_2): unknown;
+    create(base?: DeepPartial_74<PostNsfwUpdate_2>): PostNsfwUpdate_2;
+    fromPartial(object: DeepPartial_74<PostNsfwUpdate_2>): PostNsfwUpdate_2;
+};
+
+export declare type PostNsfwUpdateDefinition = {
+    event: PostNsfwUpdate;
+    onEvent: TriggerOnEventHandler<protos.PostNsfwUpdate>;
+};
+
 declare interface PostRemovalNoteRequest {
     /** list of thing ids */
     itemIds: string[];
@@ -40197,6 +40812,31 @@ export declare type PostReportDefinition = {
     onEvent: TriggerOnEventHandler<protos.PostReport>;
 };
 
+/** The event name for when a post is marked/unmarked as spoiler*/
+export declare type PostSpoilerUpdate = 'PostSpoilerUpdate';
+
+declare interface PostSpoilerUpdate_2 {
+    post?: PostV2 | undefined;
+    author?: UserV2 | undefined;
+    isSpoiler: boolean;
+    subreddit?: SubredditV2 | undefined;
+}
+
+declare const PostSpoilerUpdate_2: {
+    $type: "devvit.events.v1alpha.PostSpoilerUpdate";
+    encode(message: PostSpoilerUpdate_2, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PostSpoilerUpdate_2;
+    fromJSON(object: any): PostSpoilerUpdate_2;
+    toJSON(message: PostSpoilerUpdate_2): unknown;
+    create(base?: DeepPartial_74<PostSpoilerUpdate_2>): PostSpoilerUpdate_2;
+    fromPartial(object: DeepPartial_74<PostSpoilerUpdate_2>): PostSpoilerUpdate_2;
+};
+
+export declare type PostSpoilerUpdateDefinition = {
+    event: PostSpoilerUpdate;
+    onEvent: TriggerOnEventHandler<protos.PostSpoilerUpdate>;
+};
+
 /** The event name for when a post is submitted */
 export declare type PostSubmit = 'PostSubmit';
 
@@ -41686,6 +42326,8 @@ declare namespace protos {
         AppUpgrade_2 as AppUpgrade,
         AccountDelete,
         Vote,
+        PostNsfwUpdate_2 as PostNsfwUpdate,
+        PostSpoilerUpdate_2 as PostSpoilerUpdate,
         GetProfileRequest,
         GetProfileResponse,
         DevvitProfiler,
@@ -42472,6 +43114,14 @@ declare namespace protos {
         OnAccountDeleteServiceName,
         OnAccountDeleteClientImpl,
         OnAccountDeleteDefinition,
+        OnPostNsfwUpdate,
+        OnPostNsfwUpdateServiceName,
+        OnPostNsfwUpdateClientImpl,
+        OnPostNsfwUpdateDefinition,
+        OnPostSpoilerUpdate,
+        OnPostSpoilerUpdateServiceName,
+        OnPostSpoilerUpdateClientImpl,
+        OnPostSpoilerUpdateDefinition,
         Metadata,
         Definition,
         MethodDefinition,
@@ -56359,9 +57009,9 @@ declare const TransactionResponses: {
 
 export declare type TriggerContext = Omit<Devvit.Context, 'ui' | 'dimensions' | 'modLog' | 'uiEnvironment'>;
 
-export declare type TriggerDefinition = PostSubmitDefinition | PostCreateDefinition | PostUpdateDefinition | PostFlairUpdateDefinition | PostReportDefinition | PostDeleteDefinition | CommentSubmitDefinition | CommentCreateDefinition | CommentUpdateDefinition | CommentReportDefinition | CommentDeleteDefinition | AppInstallDefinition | AppUpgradeDefinition | ModActionDefinition | ModMailDefinition;
+export declare type TriggerDefinition = PostSubmitDefinition | PostCreateDefinition | PostUpdateDefinition | PostFlairUpdateDefinition | PostReportDefinition | PostDeleteDefinition | CommentSubmitDefinition | CommentCreateDefinition | CommentUpdateDefinition | CommentReportDefinition | CommentDeleteDefinition | AppInstallDefinition | AppUpgradeDefinition | ModActionDefinition | ModMailDefinition | PostSpoilerUpdateDefinition | PostNsfwUpdateDefinition;
 
-export declare type TriggerEvent = PostSubmit | PostCreate | PostUpdate | PostReport | PostDelete | PostFlairUpdate | CommentSubmit | CommentCreate | CommentUpdate | CommentReport | CommentDelete | AppInstall | AppUpgrade | ModActionTrigger | ModMailTrigger;
+export declare type TriggerEvent = PostSubmit | PostCreate | PostUpdate | PostReport | PostDelete | PostFlairUpdate | CommentSubmit | CommentCreate | CommentUpdate | CommentReport | CommentDelete | AppInstall | AppUpgrade | ModActionTrigger | ModMailTrigger | PostNsfwUpdate | PostSpoilerUpdate;
 
 declare interface TriggerEvent_2 {
     /** UUID for the event */
@@ -56389,6 +57039,9 @@ declare interface TriggerEvent_2 {
     vote?: Vote | undefined;
     postApprove?: PostApprove | undefined;
     commentApprove?: CommentApprove | undefined;
+    nsfwPostUpdate?: PostNsfwUpdate_2 | undefined;
+    /** NEXT: 122 */
+    spoilerPostUpdate?: PostSpoilerUpdate_2 | undefined;
 }
 
 declare const TriggerEvent_2: {
@@ -56448,6 +57101,12 @@ export declare type TriggerEventType = {
     ModMail: {
         type: 'ModMail';
     } & protos.ModMail;
+    PostNsfwUpdate: {
+        type: 'PostNsfwUpdate';
+    } & protos.PostNsfwUpdate;
+    PostSpoilerUpdate: {
+        type: 'PostSpoilerUpdate';
+    } & protos.PostSpoilerUpdate;
 };
 
 declare interface TriggerFanOutResponse {
@@ -58302,7 +58961,278 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        source?: EventSource_4;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                    } | undefined;
+                    commentApprove?: {
+                        comment?: {
+                            id?: string;
+                            parentId?: string;
+                            body?: string;
+                            author?: string;
+                            numReports?: number;
+                            collapsedBecauseCrowdControl?: boolean;
+                            spam?: boolean;
+                            deleted?: boolean;
+                            createdAt?: number;
+                            upvotes?: number;
+                            downvotes?: number;
+                            languageCode?: string;
+                            lastModifiedAt?: number;
+                            gilded?: boolean;
+                            score?: number;
+                            permalink?: string;
+                            hasMedia?: boolean;
+                            postId?: string;
+                            subredditId?: string;
+                            elementTypes?: string[];
+                        } | undefined;
+                        post?: {
+                            id?: string;
+                            title?: string;
+                            selftext?: string;
+                            nsfw?: boolean;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
+                        approvedAt?: Date | 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;
+                        source?: EventSource_4;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                    } | undefined;
+                    nsfwPostUpdate?: {
+                        post?: {
+                            id?: string;
+                            title?: string;
+                            selftext?: string;
+                            nsfw?: boolean;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
@@ -58316,29 +59246,7 @@ declare const TriggersDefinition: {
                             permalink?: string;
                         } | undefined;
                     } | undefined;
-                    commentApprove?: {
-                        comment?: {
-                            id?: string;
-                            parentId?: string;
-                            body?: string;
-                            author?: string;
-                            numReports?: number;
-                            collapsedBecauseCrowdControl?: boolean;
-                            spam?: boolean;
-                            deleted?: boolean;
-                            createdAt?: number;
-                            upvotes?: number;
-                            downvotes?: number;
-                            languageCode?: string;
-                            lastModifiedAt?: number;
-                            gilded?: boolean;
-                            score?: number;
-                            permalink?: string;
-                            hasMedia?: boolean;
-                            postId?: string;
-                            subredditId?: string;
-                            elementTypes?: string[];
-                        } | undefined;
+                    spoilerPostUpdate?: {
                         post?: {
                             id?: string;
                             title?: string;
@@ -58427,7 +59335,6 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                        approvedAt?: Date | undefined;
                         author?: {
                             id?: string;
                             name?: string;
@@ -58449,7 +59356,7 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        isSpoiler?: boolean;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -59724,64 +60631,256 @@ declare const TriggersDefinition: {
                             iconImage?: string;
                         } | undefined;
                     } | undefined;
-                    modAction?: {
-                        action?: string | undefined;
-                        actionedAt?: Date | undefined;
-                        subreddit?: {
-                            id?: string;
-                            name?: string;
-                            nsfw?: boolean;
-                            type?: SubredditType_4;
-                            spam?: boolean;
-                            quarantined?: boolean;
-                            topics?: string[];
-                            rating?: SubredditRating_3;
-                            subscribersCount?: number;
-                            permalink?: string;
-                        } | undefined;
-                        moderator?: {
-                            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;
-                        targetUser?: {
-                            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;
-                        targetComment?: {
+                    modAction?: {
+                        action?: string | undefined;
+                        actionedAt?: Date | undefined;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                        moderator?: {
+                            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;
+                        targetUser?: {
+                            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;
+                        targetComment?: {
+                            id?: string;
+                            parentId?: string;
+                            body?: string;
+                            author?: string;
+                            numReports?: number;
+                            collapsedBecauseCrowdControl?: boolean;
+                            spam?: boolean;
+                            deleted?: boolean;
+                            createdAt?: number;
+                            upvotes?: number;
+                            downvotes?: number;
+                            languageCode?: string;
+                            lastModifiedAt?: number;
+                            gilded?: boolean;
+                            score?: number;
+                            permalink?: string;
+                            hasMedia?: boolean;
+                            postId?: string;
+                            subredditId?: string;
+                            elementTypes?: string[];
+                        } | undefined;
+                        targetPost?: {
+                            id?: string;
+                            title?: string;
+                            selftext?: string;
+                            nsfw?: boolean;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
+                    } | undefined;
+                    modMail?: {
+                        messageAuthor?: {
+                            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;
+                        createdAt?: Date | undefined;
+                        messageAuthorType?: string;
+                        conversationState?: string;
+                        conversationType?: string;
+                        isAutoGenerated?: boolean;
+                        conversationSubreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                        destinationSubreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                        conversationId?: string;
+                        messageId?: string;
+                    } | undefined;
+                    accountDelete?: {
+                        userId?: string;
+                        deletedAt?: Date | undefined;
+                        user?: {
+                            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;
+                    } | undefined;
+                    vote?: {
+                        updatedAt?: Date | undefined;
+                        comment?: {
                             id?: string;
                             parentId?: string;
                             body?: string;
@@ -59803,7 +60902,7 @@ declare const TriggersDefinition: {
                             subredditId?: string;
                             elementTypes?: string[];
                         } | undefined;
-                        targetPost?: {
+                        post?: {
                             id?: string;
                             title?: string;
                             selftext?: string;
@@ -59891,35 +60990,7 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                    } | undefined;
-                    modMail?: {
-                        messageAuthor?: {
-                            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;
-                        createdAt?: Date | undefined;
-                        messageAuthorType?: string;
-                        conversationState?: string;
-                        conversationType?: string;
-                        isAutoGenerated?: boolean;
-                        conversationSubreddit?: {
+                        subreddit?: {
                             id?: string;
                             name?: string;
                             nsfw?: boolean;
@@ -59931,25 +61002,100 @@ declare const TriggersDefinition: {
                             subscribersCount?: number;
                             permalink?: string;
                         } | undefined;
-                        destinationSubreddit?: {
+                        upvoteRatio?: number;
+                        score?: number;
+                    } | undefined;
+                    postApprove?: {
+                        post?: {
                             id?: string;
-                            name?: string;
+                            title?: string;
+                            selftext?: string;
                             nsfw?: boolean;
-                            type?: SubredditType_4;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
-                            quarantined?: boolean;
-                            topics?: string[];
-                            rating?: SubredditRating_3;
-                            subscribersCount?: number;
+                            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;
-                        conversationId?: string;
-                        messageId?: string;
-                    } | undefined;
-                    accountDelete?: {
-                        userId?: string;
-                        deletedAt?: Date | undefined;
-                        user?: {
+                        approvedAt?: Date | undefined;
+                        author?: {
                             id?: string;
                             name?: string;
                             isGold?: boolean;
@@ -59970,9 +61116,21 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
+                        source?: EventSource_4;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
                     } | undefined;
-                    vote?: {
-                        updatedAt?: Date | undefined;
+                    commentApprove?: {
                         comment?: {
                             id?: string;
                             parentId?: string;
@@ -60083,6 +61241,29 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
+                        approvedAt?: Date | 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;
+                        source?: EventSource_4;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -60095,10 +61276,8 @@ declare const TriggersDefinition: {
                             subscribersCount?: number;
                             permalink?: string;
                         } | undefined;
-                        upvoteRatio?: number;
-                        score?: number;
                     } | undefined;
-                    postApprove?: {
+                    nsfwPostUpdate?: {
                         post?: {
                             id?: string;
                             title?: string;
@@ -60187,7 +61366,6 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                        approvedAt?: Date | undefined;
                         author?: {
                             id?: string;
                             name?: string;
@@ -60209,7 +61387,7 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        isNsfw?: boolean;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -60223,29 +61401,7 @@ declare const TriggersDefinition: {
                             permalink?: string;
                         } | undefined;
                     } | undefined;
-                    commentApprove?: {
-                        comment?: {
-                            id?: string;
-                            parentId?: string;
-                            body?: string;
-                            author?: string;
-                            numReports?: number;
-                            collapsedBecauseCrowdControl?: boolean;
-                            spam?: boolean;
-                            deleted?: boolean;
-                            createdAt?: number;
-                            upvotes?: number;
-                            downvotes?: number;
-                            languageCode?: string;
-                            lastModifiedAt?: number;
-                            gilded?: boolean;
-                            score?: number;
-                            permalink?: string;
-                            hasMedia?: boolean;
-                            postId?: string;
-                            subredditId?: string;
-                            elementTypes?: string[];
-                        } | undefined;
+                    spoilerPostUpdate?: {
                         post?: {
                             id?: string;
                             title?: string;
@@ -60334,7 +61490,6 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                        approvedAt?: Date | undefined;
                         author?: {
                             id?: string;
                             name?: string;
@@ -60356,7 +61511,7 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        isSpoiler?: boolean;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -62138,7 +63293,278 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        source?: EventSource_4;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                    } | undefined;
+                    commentApprove?: {
+                        comment?: {
+                            id?: string;
+                            parentId?: string;
+                            body?: string;
+                            author?: string;
+                            numReports?: number;
+                            collapsedBecauseCrowdControl?: boolean;
+                            spam?: boolean;
+                            deleted?: boolean;
+                            createdAt?: number;
+                            upvotes?: number;
+                            downvotes?: number;
+                            languageCode?: string;
+                            lastModifiedAt?: number;
+                            gilded?: boolean;
+                            score?: number;
+                            permalink?: string;
+                            hasMedia?: boolean;
+                            postId?: string;
+                            subredditId?: string;
+                            elementTypes?: string[];
+                        } | undefined;
+                        post?: {
+                            id?: string;
+                            title?: string;
+                            selftext?: string;
+                            nsfw?: boolean;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
+                        approvedAt?: Date | 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;
+                        source?: EventSource_4;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                    } | undefined;
+                    nsfwPostUpdate?: {
+                        post?: {
+                            id?: string;
+                            title?: string;
+                            selftext?: string;
+                            nsfw?: boolean;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
@@ -62152,29 +63578,7 @@ declare const TriggersDefinition: {
                             permalink?: string;
                         } | undefined;
                     } | undefined;
-                    commentApprove?: {
-                        comment?: {
-                            id?: string;
-                            parentId?: string;
-                            body?: string;
-                            author?: string;
-                            numReports?: number;
-                            collapsedBecauseCrowdControl?: boolean;
-                            spam?: boolean;
-                            deleted?: boolean;
-                            createdAt?: number;
-                            upvotes?: number;
-                            downvotes?: number;
-                            languageCode?: string;
-                            lastModifiedAt?: number;
-                            gilded?: boolean;
-                            score?: number;
-                            permalink?: string;
-                            hasMedia?: boolean;
-                            postId?: string;
-                            subredditId?: string;
-                            elementTypes?: string[];
-                        } | undefined;
+                    spoilerPostUpdate?: {
                         post?: {
                             id?: string;
                             title?: string;
@@ -62263,7 +63667,6 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                        approvedAt?: Date | undefined;
                         author?: {
                             id?: string;
                             name?: string;
@@ -62285,7 +63688,7 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        isSpoiler?: boolean;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -63560,64 +64963,256 @@ declare const TriggersDefinition: {
                             iconImage?: string;
                         } | undefined;
                     } | undefined;
-                    modAction?: {
-                        action?: string | undefined;
-                        actionedAt?: Date | undefined;
-                        subreddit?: {
-                            id?: string;
-                            name?: string;
-                            nsfw?: boolean;
-                            type?: SubredditType_4;
-                            spam?: boolean;
-                            quarantined?: boolean;
-                            topics?: string[];
-                            rating?: SubredditRating_3;
-                            subscribersCount?: number;
-                            permalink?: string;
-                        } | undefined;
-                        moderator?: {
-                            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;
-                        targetUser?: {
-                            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;
-                        targetComment?: {
+                    modAction?: {
+                        action?: string | undefined;
+                        actionedAt?: Date | undefined;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                        moderator?: {
+                            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;
+                        targetUser?: {
+                            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;
+                        targetComment?: {
+                            id?: string;
+                            parentId?: string;
+                            body?: string;
+                            author?: string;
+                            numReports?: number;
+                            collapsedBecauseCrowdControl?: boolean;
+                            spam?: boolean;
+                            deleted?: boolean;
+                            createdAt?: number;
+                            upvotes?: number;
+                            downvotes?: number;
+                            languageCode?: string;
+                            lastModifiedAt?: number;
+                            gilded?: boolean;
+                            score?: number;
+                            permalink?: string;
+                            hasMedia?: boolean;
+                            postId?: string;
+                            subredditId?: string;
+                            elementTypes?: string[];
+                        } | undefined;
+                        targetPost?: {
+                            id?: string;
+                            title?: string;
+                            selftext?: string;
+                            nsfw?: boolean;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
+                    } | undefined;
+                    modMail?: {
+                        messageAuthor?: {
+                            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;
+                        createdAt?: Date | undefined;
+                        messageAuthorType?: string;
+                        conversationState?: string;
+                        conversationType?: string;
+                        isAutoGenerated?: boolean;
+                        conversationSubreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                        destinationSubreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
+                        conversationId?: string;
+                        messageId?: string;
+                    } | undefined;
+                    accountDelete?: {
+                        userId?: string;
+                        deletedAt?: Date | undefined;
+                        user?: {
+                            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;
+                    } | undefined;
+                    vote?: {
+                        updatedAt?: Date | undefined;
+                        comment?: {
                             id?: string;
                             parentId?: string;
                             body?: string;
@@ -63639,7 +65234,7 @@ declare const TriggersDefinition: {
                             subredditId?: string;
                             elementTypes?: string[];
                         } | undefined;
-                        targetPost?: {
+                        post?: {
                             id?: string;
                             title?: string;
                             selftext?: string;
@@ -63727,35 +65322,7 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                    } | undefined;
-                    modMail?: {
-                        messageAuthor?: {
-                            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;
-                        createdAt?: Date | undefined;
-                        messageAuthorType?: string;
-                        conversationState?: string;
-                        conversationType?: string;
-                        isAutoGenerated?: boolean;
-                        conversationSubreddit?: {
+                        subreddit?: {
                             id?: string;
                             name?: string;
                             nsfw?: boolean;
@@ -63767,25 +65334,100 @@ declare const TriggersDefinition: {
                             subscribersCount?: number;
                             permalink?: string;
                         } | undefined;
-                        destinationSubreddit?: {
+                        upvoteRatio?: number;
+                        score?: number;
+                    } | undefined;
+                    postApprove?: {
+                        post?: {
                             id?: string;
-                            name?: string;
+                            title?: string;
+                            selftext?: string;
                             nsfw?: boolean;
-                            type?: SubredditType_4;
+                            authorId?: string;
+                            crowdControlLevel?: CrowdControlLevel_3;
+                            numReports?: number;
+                            isGallery?: boolean;
+                            isMeta?: boolean;
+                            createdAt?: number;
+                            isApproved?: boolean;
+                            isArchived?: boolean;
+                            distinguished?: DistinguishType_3;
+                            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;
-                            quarantined?: boolean;
-                            topics?: string[];
-                            rating?: SubredditRating_3;
-                            subscribersCount?: number;
+                            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;
-                        conversationId?: string;
-                        messageId?: string;
-                    } | undefined;
-                    accountDelete?: {
-                        userId?: string;
-                        deletedAt?: Date | undefined;
-                        user?: {
+                        approvedAt?: Date | undefined;
+                        author?: {
                             id?: string;
                             name?: string;
                             isGold?: boolean;
@@ -63806,9 +65448,21 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
+                        source?: EventSource_4;
+                        subreddit?: {
+                            id?: string;
+                            name?: string;
+                            nsfw?: boolean;
+                            type?: SubredditType_4;
+                            spam?: boolean;
+                            quarantined?: boolean;
+                            topics?: string[];
+                            rating?: SubredditRating_3;
+                            subscribersCount?: number;
+                            permalink?: string;
+                        } | undefined;
                     } | undefined;
-                    vote?: {
-                        updatedAt?: Date | undefined;
+                    commentApprove?: {
                         comment?: {
                             id?: string;
                             parentId?: string;
@@ -63919,6 +65573,29 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
+                        approvedAt?: Date | 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;
+                        source?: EventSource_4;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -63931,10 +65608,8 @@ declare const TriggersDefinition: {
                             subscribersCount?: number;
                             permalink?: string;
                         } | undefined;
-                        upvoteRatio?: number;
-                        score?: number;
                     } | undefined;
-                    postApprove?: {
+                    nsfwPostUpdate?: {
                         post?: {
                             id?: string;
                             title?: string;
@@ -64023,7 +65698,6 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                        approvedAt?: Date | undefined;
                         author?: {
                             id?: string;
                             name?: string;
@@ -64045,7 +65719,7 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        isNsfw?: boolean;
                         subreddit?: {
                             id?: string;
                             name?: string;
@@ -64059,29 +65733,7 @@ declare const TriggersDefinition: {
                             permalink?: string;
                         } | undefined;
                     } | undefined;
-                    commentApprove?: {
-                        comment?: {
-                            id?: string;
-                            parentId?: string;
-                            body?: string;
-                            author?: string;
-                            numReports?: number;
-                            collapsedBecauseCrowdControl?: boolean;
-                            spam?: boolean;
-                            deleted?: boolean;
-                            createdAt?: number;
-                            upvotes?: number;
-                            downvotes?: number;
-                            languageCode?: string;
-                            lastModifiedAt?: number;
-                            gilded?: boolean;
-                            score?: number;
-                            permalink?: string;
-                            hasMedia?: boolean;
-                            postId?: string;
-                            subredditId?: string;
-                            elementTypes?: string[];
-                        } | undefined;
+                    spoilerPostUpdate?: {
                         post?: {
                             id?: string;
                             title?: string;
@@ -64170,7 +65822,6 @@ declare const TriggersDefinition: {
                             type?: string;
                             unlisted?: boolean;
                         } | undefined;
-                        approvedAt?: Date | undefined;
                         author?: {
                             id?: string;
                             name?: string;
@@ -64192,7 +65843,7 @@ declare const TriggersDefinition: {
                             karma?: number;
                             iconImage?: string;
                         } | undefined;
-                        source?: EventSource_4;
+                        isSpoiler?: boolean;
                         subreddit?: {
                             id?: string;
                             name?: string;