@devvit/protos 0.10.19-next-2024-04-23-27f06a745.0 → 0.10.19

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

@@ -4,7 +4,7 @@
  * @packageDocumentation
  */
 import _m0 from 'protobufjs/minimal.js';
-import { Metadata, MethodDefinition } from "../../../../../lib/Types.js";
+import { Metadata } from "../../../../../lib/Types.js";
 import { AccountDelete, AppInstall, AppUpgrade, CommentApprove, CommentCreate, CommentDelete, CommentReport, CommentSubmit, CommentUpdate, PostApprove, PostCreate, PostDelete, PostFlairUpdate, PostReport, PostSubmit, PostUpdate, SubredditSubscribe } from '../../../events/v1alpha/events.js';
 import { ModAction } from '../../../reddit/v2alpha/modaction.js';
 import { ModMail } from '../../../reddit/v2alpha/modmail.js';
@@ -34,11 +34,276 @@ export declare class OnPostSubmitClientImpl implements OnPostSubmit {
 }
 export type OnPostSubmitDefinition = typeof OnPostSubmitDefinition;
 export declare const OnPostSubmitDefinition: {
-    name: 'OnPostSubmit';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    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, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostSubmit;
+                fromJSON(object: any): PostSubmit;
+                toJSON(message: PostSubmit): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostSubmit;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostSubmit;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -56,11 +321,276 @@ export declare class OnPostCreateClientImpl implements OnPostCreate {
 }
 export type OnPostCreateDefinition = typeof OnPostCreateDefinition;
 export declare const OnPostCreateDefinition: {
-    name: 'OnPostCreate';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnPostCreate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostCreate";
+    readonly methods: {
+        readonly onPostCreate: {
+            readonly name: "OnPostCreate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostCreate";
+                encode(message: PostCreate, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostCreate;
+                fromJSON(object: any): PostCreate;
+                toJSON(message: PostCreate): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostCreate;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostCreate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -78,11 +608,278 @@ export declare class OnPostUpdateClientImpl implements OnPostUpdate {
 }
 export type OnPostUpdateDefinition = typeof OnPostUpdateDefinition;
 export declare const OnPostUpdateDefinition: {
-    name: 'OnPostUpdate';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    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, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostUpdate;
+                fromJSON(object: any): PostUpdate;
+                toJSON(message: PostUpdate): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    previousBody?: string;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostUpdate;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    previousBody?: string;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostUpdate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -100,11 +897,236 @@ export declare class OnPostReportClientImpl implements OnPostReport {
 }
 export type OnPostReportDefinition = typeof OnPostReportDefinition;
 export declare const OnPostReportDefinition: {
-    name: 'OnPostReport';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnPostReport";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostReport";
+    readonly methods: {
+        readonly onPostReport: {
+            readonly name: "OnPostReport";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostReport";
+                encode(message: PostReport, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostReport;
+                fromJSON(object: any): PostReport;
+                toJSON(message: PostReport): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    reason?: string;
+                } | undefined): PostReport;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    reason?: string;
+                }): PostReport;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -122,11 +1144,276 @@ export declare class OnPostFlairUpdateClientImpl implements OnPostFlairUpdate {
 }
 export type OnPostFlairUpdateDefinition = typeof OnPostFlairUpdateDefinition;
 export declare const OnPostFlairUpdateDefinition: {
-    name: 'OnPostFlairUpdate';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnPostFlairUpdate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostFlairUpdate";
+    readonly methods: {
+        readonly onPostFlairUpdate: {
+            readonly name: "OnPostFlairUpdate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostFlairUpdate";
+                encode(message: PostFlairUpdate, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostFlairUpdate;
+                fromJSON(object: any): PostFlairUpdate;
+                toJSON(message: PostFlairUpdate): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostFlairUpdate;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    author?: {
+                        id?: string;
+                        name?: string;
+                        isGold?: boolean;
+                        snoovatarImage?: string;
+                        url?: string;
+                        spam?: boolean;
+                        banned?: boolean;
+                        flair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        karma?: number;
+                        iconImage?: string;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostFlairUpdate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -144,11 +1431,110 @@ export declare class OnPostDeleteClientImpl implements OnPostDelete {
 }
 export type OnPostDeleteDefinition = typeof OnPostDeleteDefinition;
 export declare const OnPostDeleteDefinition: {
-    name: 'OnPostDelete';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnPostDelete";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostDelete";
+    readonly methods: {
+        readonly onPostDelete: {
+            readonly name: "OnPostDelete";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostDelete";
+                encode(message: PostDelete, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostDelete;
+                fromJSON(object: any): PostDelete;
+                toJSON(message: PostDelete): unknown;
+                create(base?: {
+                    postId?: string;
+                    deletedAt?: 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;
+                    createdAt?: Date | undefined;
+                    source?: import("../../../events/v1alpha/events.js").EventSource;
+                    reason?: import("../../../events/v1alpha/events.js").DeletionReason;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostDelete;
+                fromPartial(object: {
+                    postId?: string;
+                    deletedAt?: 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;
+                    createdAt?: Date | undefined;
+                    source?: import("../../../events/v1alpha/events.js").EventSource;
+                    reason?: import("../../../events/v1alpha/events.js").DeletionReason;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostDelete;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -166,11 +1552,280 @@ export declare class OnPostApproveClientImpl implements OnPostApprove {
 }
 export type OnPostApproveDefinition = typeof OnPostApproveDefinition;
 export declare const OnPostApproveDefinition: {
-    name: 'OnPostApprove';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnPostApprove";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnPostApprove";
+    readonly methods: {
+        readonly onPostApprove: {
+            readonly name: "OnPostApprove";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.PostApprove";
+                encode(message: PostApprove, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PostApprove;
+                fromJSON(object: any): PostApprove;
+                toJSON(message: PostApprove): unknown;
+                create(base?: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    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?: import("../../../events/v1alpha/events.js").EventSource;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): PostApprove;
+                fromPartial(object: {
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    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?: import("../../../events/v1alpha/events.js").EventSource;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): PostApprove;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -188,11 +1843,320 @@ export declare class OnCommentSubmitClientImpl implements OnCommentSubmit {
 }
 export type OnCommentSubmitDefinition = typeof OnCommentSubmitDefinition;
 export declare const OnCommentSubmitDefinition: {
-    name: 'OnCommentSubmit';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnCommentSubmit";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnCommentSubmit";
+    readonly methods: {
+        readonly onCommentSubmit: {
+            readonly name: "OnCommentSubmit";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.CommentSubmit";
+                encode(message: CommentSubmit, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): CommentSubmit;
+                fromJSON(object: any): CommentSubmit;
+                toJSON(message: CommentSubmit): unknown;
+                create(base?: {
+                    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;
+                    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;
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): CommentSubmit;
+                fromPartial(object: {
+                    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;
+                    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;
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): CommentSubmit;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -210,11 +2174,320 @@ export declare class OnCommentCreateClientImpl implements OnCommentCreate {
 }
 export type OnCommentCreateDefinition = typeof OnCommentCreateDefinition;
 export declare const OnCommentCreateDefinition: {
-    name: 'OnCommentCreate';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnCommentCreate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnCommentCreate";
+    readonly methods: {
+        readonly onCommentCreate: {
+            readonly name: "OnCommentCreate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.CommentCreate";
+                encode(message: CommentCreate, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): CommentCreate;
+                fromJSON(object: any): CommentCreate;
+                toJSON(message: CommentCreate): unknown;
+                create(base?: {
+                    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;
+                    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;
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): CommentCreate;
+                fromPartial(object: {
+                    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;
+                    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;
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): CommentCreate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -232,11 +2505,322 @@ export declare class OnCommentUpdateClientImpl implements OnCommentUpdate {
 }
 export type OnCommentUpdateDefinition = typeof OnCommentUpdateDefinition;
 export declare const OnCommentUpdateDefinition: {
-    name: 'OnCommentUpdate';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnCommentUpdate";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnCommentUpdate";
+    readonly methods: {
+        readonly onCommentUpdate: {
+            readonly name: "OnCommentUpdate";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.CommentUpdate";
+                encode(message: CommentUpdate, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): CommentUpdate;
+                fromJSON(object: any): CommentUpdate;
+                toJSON(message: CommentUpdate): unknown;
+                create(base?: {
+                    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;
+                    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;
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    previousBody?: string;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): CommentUpdate;
+                fromPartial(object: {
+                    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;
+                    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;
+                    post?: {
+                        id?: string;
+                        title?: string;
+                        selftext?: string;
+                        nsfw?: boolean;
+                        authorId?: string;
+                        crowdControlLevel?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    previousBody?: string;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): CommentUpdate;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -254,11 +2838,104 @@ export declare class OnCommentReportClientImpl implements OnCommentReport {
 }
 export type OnCommentReportDefinition = typeof OnCommentReportDefinition;
 export declare const OnCommentReportDefinition: {
-    name: 'OnCommentReport';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnCommentReport";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnCommentReport";
+    readonly methods: {
+        readonly onCommentReport: {
+            readonly name: "OnCommentReport";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.CommentReport";
+                encode(message: CommentReport, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): CommentReport;
+                fromJSON(object: any): CommentReport;
+                toJSON(message: CommentReport): unknown;
+                create(base?: {
+                    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;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    reason?: string;
+                } | undefined): CommentReport;
+                fromPartial(object: {
+                    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;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    reason?: string;
+                }): CommentReport;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -276,11 +2953,114 @@ export declare class OnCommentDeleteClientImpl implements OnCommentDelete {
 }
 export type OnCommentDeleteDefinition = typeof OnCommentDeleteDefinition;
 export declare const OnCommentDeleteDefinition: {
-    name: 'OnCommentDelete';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnCommentDelete";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnCommentDelete";
+    readonly methods: {
+        readonly onCommentDelete: {
+            readonly name: "OnCommentDelete";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.CommentDelete";
+                encode(message: CommentDelete, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): CommentDelete;
+                fromJSON(object: any): CommentDelete;
+                toJSON(message: CommentDelete): unknown;
+                create(base?: {
+                    commentId?: string;
+                    postId?: string;
+                    parentId?: string;
+                    deletedAt?: 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;
+                    createdAt?: Date | undefined;
+                    source?: import("../../../events/v1alpha/events.js").EventSource;
+                    reason?: import("../../../events/v1alpha/events.js").DeletionReason;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): CommentDelete;
+                fromPartial(object: {
+                    commentId?: string;
+                    postId?: string;
+                    parentId?: string;
+                    deletedAt?: 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;
+                    createdAt?: Date | undefined;
+                    source?: import("../../../events/v1alpha/events.js").EventSource;
+                    reason?: import("../../../events/v1alpha/events.js").DeletionReason;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): CommentDelete;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -298,11 +3078,324 @@ export declare class OnCommentApproveClientImpl implements OnCommentApprove {
 }
 export type OnCommentApproveDefinition = typeof OnCommentApproveDefinition;
 export declare const OnCommentApproveDefinition: {
-    name: 'OnCommentApprove';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnCommentApprove";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnCommentApprove";
+    readonly methods: {
+        readonly onCommentApprove: {
+            readonly name: "OnCommentApprove";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.CommentApprove";
+                encode(message: CommentApprove, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): CommentApprove;
+                fromJSON(object: any): CommentApprove;
+                toJSON(message: CommentApprove): unknown;
+                create(base?: {
+                    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?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    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?: import("../../../events/v1alpha/events.js").EventSource;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                } | undefined): CommentApprove;
+                fromPartial(object: {
+                    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?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                    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?: import("../../../events/v1alpha/events.js").EventSource;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                }): CommentApprove;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -320,11 +3413,100 @@ export declare class OnSubredditSubscribeClientImpl implements OnSubredditSubscr
 }
 export type OnSubredditSubscribeDefinition = typeof OnSubredditSubscribeDefinition;
 export declare const OnSubredditSubscribeDefinition: {
-    name: 'OnSubredditSubscribe';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnSubredditSubscribe";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnSubredditSubscribe";
+    readonly methods: {
+        readonly onSubredditSubscribe: {
+            readonly name: "OnSubredditSubscribe";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.SubredditSubscribe";
+                encode(message: SubredditSubscribe, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): SubredditSubscribe;
+                fromJSON(object: any): SubredditSubscribe;
+                toJSON(message: SubredditSubscribe): unknown;
+                create(base?: {
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    subscriber?: {
+                        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): SubredditSubscribe;
+                fromPartial(object: {
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    subscriber?: {
+                        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;
+                }): SubredditSubscribe;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -342,11 +3524,100 @@ export declare class OnAppInstallClientImpl implements OnAppInstall {
 }
 export type OnAppInstallDefinition = typeof OnAppInstallDefinition;
 export declare const OnAppInstallDefinition: {
-    name: 'OnAppInstall';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnAppInstall";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnAppInstall";
+    readonly methods: {
+        readonly onAppInstall: {
+            readonly name: "OnAppInstall";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.AppInstall";
+                encode(message: AppInstall, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): AppInstall;
+                fromJSON(object: any): AppInstall;
+                toJSON(message: AppInstall): unknown;
+                create(base?: {
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    installer?: {
+                        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): AppInstall;
+                fromPartial(object: {
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    installer?: {
+                        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;
+                }): AppInstall;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -364,11 +3635,100 @@ export declare class OnAppUpgradeClientImpl implements OnAppUpgrade {
 }
 export type OnAppUpgradeDefinition = typeof OnAppUpgradeDefinition;
 export declare const OnAppUpgradeDefinition: {
-    name: 'OnAppUpgrade';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnAppUpgrade";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnAppUpgrade";
+    readonly methods: {
+        readonly onAppUpgrade: {
+            readonly name: "OnAppUpgrade";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.AppUpgrade";
+                encode(message: AppUpgrade, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): AppUpgrade;
+                fromJSON(object: any): AppUpgrade;
+                toJSON(message: AppUpgrade): unknown;
+                create(base?: {
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    installer?: {
+                        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): AppUpgrade;
+                fromPartial(object: {
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    installer?: {
+                        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;
+                }): AppUpgrade;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -386,11 +3746,366 @@ export declare class OnModActionClientImpl implements OnModAction {
 }
 export type OnModActionDefinition = typeof OnModActionDefinition;
 export declare const OnModActionDefinition: {
-    name: 'OnModAction';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnModAction";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnModAction";
+    readonly methods: {
+        readonly onModAction: {
+            readonly name: "OnModAction";
+            readonly requestType: {
+                $type: "devvit.reddit.v2alpha.ModAction";
+                encode(message: ModAction, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ModAction;
+                fromJSON(object: any): ModAction;
+                toJSON(message: ModAction): unknown;
+                create(base?: {
+                    action?: string | undefined;
+                    actionedAt?: Date | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    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?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                } | undefined): ModAction;
+                fromPartial(object: {
+                    action?: string | undefined;
+                    actionedAt?: Date | undefined;
+                    subreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    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?: import("../../../reddit/v2alpha/postv2.js").CrowdControlLevel;
+                        numReports?: number;
+                        isGallery?: boolean;
+                        isMeta?: boolean;
+                        createdAt?: number;
+                        isApproved?: boolean;
+                        isArchived?: boolean;
+                        distinguished?: import("../../../reddit/v2alpha/postv2.js").DistinguishType;
+                        ignoreReports?: boolean;
+                        isSelf?: boolean;
+                        isVideo?: boolean;
+                        isLocked?: boolean;
+                        isSpoiler?: boolean;
+                        subredditId?: string;
+                        upvotes?: number;
+                        downvotes?: number;
+                        url?: string;
+                        isSticky?: boolean;
+                        linkFlair?: {
+                            text?: string;
+                            cssClass?: string;
+                            backgroundColor?: string;
+                            templateId?: string;
+                            textColor?: string;
+                        } | undefined;
+                        authorFlair?: {
+                            userId?: string;
+                            subredditId?: string;
+                            text?: string;
+                            cssClass?: string;
+                            templateId?: string;
+                            textColor?: string;
+                            backgroundColor?: string;
+                            enabled?: boolean;
+                        } | undefined;
+                        spam?: boolean;
+                        deleted?: boolean;
+                        languageCode?: string;
+                        updatedAt?: number;
+                        gildings?: number;
+                        score?: number;
+                        numComments?: number;
+                        thumbnail?: string;
+                        media?: {
+                            type?: string;
+                            oembed?: {
+                                type?: string;
+                                version?: string;
+                                title?: string;
+                                description?: string;
+                                authorName?: string;
+                                authorUrl?: string;
+                                providerName?: string;
+                                providerUrl?: string;
+                                thumbnailUrl?: string;
+                                thumbnailWidth?: number;
+                                thumbnailHeight?: number;
+                                html?: string;
+                                width?: number;
+                                height?: number;
+                            } | undefined;
+                            redditVideo?: {
+                                bitrateKbps?: number;
+                                fallbackUrl?: string;
+                                height?: number;
+                                width?: number;
+                                scrubberMediaUrl?: string;
+                                dashUrl?: string;
+                                duration?: number;
+                                hlsUrl?: string;
+                                isGif?: boolean;
+                                transcodingStatus?: string;
+                            } | undefined;
+                        } | undefined;
+                        crosspostParentId?: string;
+                        permalink?: string;
+                        isPoll?: boolean;
+                        isPromoted?: boolean;
+                        isMultiMedia?: boolean;
+                        type?: string;
+                        unlisted?: boolean;
+                    } | undefined;
+                }): ModAction;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -408,11 +4123,138 @@ export declare class OnModMailClientImpl implements OnModMail {
 }
 export type OnModMailDefinition = typeof OnModMailDefinition;
 export declare const OnModMailDefinition: {
-    name: 'OnModMail';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnModMail";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnModMail";
+    readonly methods: {
+        readonly onModMail: {
+            readonly name: "OnModMail";
+            readonly requestType: {
+                $type: "devvit.reddit.v2alpha.ModMail";
+                encode(message: ModMail, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ModMail;
+                fromJSON(object: any): ModMail;
+                toJSON(message: ModMail): unknown;
+                create(base?: {
+                    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?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    destinationSubreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    conversationId?: string;
+                    messageId?: string;
+                } | undefined): ModMail;
+                fromPartial(object: {
+                    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?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    destinationSubreddit?: {
+                        id?: string;
+                        name?: string;
+                        nsfw?: boolean;
+                        type?: import("../../../reddit/v2alpha/subredditv2.js").SubredditType;
+                        spam?: boolean;
+                        quarantined?: boolean;
+                        topics?: string[];
+                        rating?: import("../../../reddit/v2alpha/subredditv2.js").SubredditRating;
+                        subscribersCount?: number;
+                        permalink?: string;
+                    } | undefined;
+                    conversationId?: string;
+                    messageId?: string;
+                }): ModMail;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };
@@ -430,11 +4272,80 @@ export declare class OnAccountDeleteClientImpl implements OnAccountDelete {
 }
 export type OnAccountDeleteDefinition = typeof OnAccountDeleteDefinition;
 export declare const OnAccountDeleteDefinition: {
-    name: 'OnAccountDelete';
-    fullName: string;
-    methods: {
-        [methodName: string]: MethodDefinition & {
-            options: {};
+    readonly name: "OnAccountDelete";
+    readonly fullName: "devvit.actor.automation.v1alpha.OnAccountDelete";
+    readonly methods: {
+        readonly onAccountDelete: {
+            readonly name: "OnAccountDelete";
+            readonly requestType: {
+                $type: "devvit.events.v1alpha.AccountDelete";
+                encode(message: AccountDelete, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number | undefined): AccountDelete;
+                fromJSON(object: any): AccountDelete;
+                toJSON(message: AccountDelete): unknown;
+                create(base?: {
+                    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): AccountDelete;
+                fromPartial(object: {
+                    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;
+                }): AccountDelete;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                $type: "devvit.actor.automation.v1alpha.HandlerResult";
+                encode(_: HandlerResult, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HandlerResult;
+                fromJSON(_: any): HandlerResult;
+                toJSON(_: HandlerResult): unknown;
+                create(base?: DeepPartial<HandlerResult>): HandlerResult;
+                fromPartial(_: DeepPartial<HandlerResult>): HandlerResult;
+            };
+            readonly responseStream: false;
+            readonly options: {};
         };
     };
 };