@devvit/reddit 0.11.17-next-2025-05-28-417d95f5a.0

package/models/Post.js

@@ -0,0 +1,1022 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _Post_id, _Post_authorId, _Post_authorName, _Post_createdAt, _Post_subredditId, _Post_subredditName, _Post_permalink, _Post_title, _Post_body, _Post_bodyHtml, _Post_url, _Post_score, _Post_numberOfComments, _Post_numberOfReports, _Post_thumbnail, _Post_approved, _Post_approvedAtUtc, _Post_bannedAtUtc, _Post_spam, _Post_stickied, _Post_removed, _Post_removedBy, _Post_removedByCategory, _Post_archived, _Post_edited, _Post_locked, _Post_nsfw, _Post_quarantined, _Post_spoiler, _Post_hidden, _Post_ignoringReports, _Post_distinguishedBy, _Post_flair, _Post_secureMedia, _Post_modReportReasons, _Post_userReportReasons, _Post_gallery, _Post_metadata_get;
+import { Block, UIResponse } from '@devvit/protos';
+import { BlocksReconciler } from '@devvit/public-api/devvit/internals/blocks/BlocksReconciler.js';
+import { BlocksHandler } from '@devvit/public-api/devvit/internals/blocks/handler/BlocksHandler.js';
+import { getContext } from '@devvit/server';
+import { assertNonNull } from '@devvit/shared-types/NonNull.js';
+import { RichTextBuilder } from '@devvit/shared-types/richtext/RichTextBuilder.js';
+import { asT2ID, asT3ID, asT5ID, isT3ID } from '@devvit/shared-types/tid.js';
+import { RunAs } from '../common.js';
+import { getRedditApiPlugins } from '../getRedditApiPlugins.js';
+import { getUserActionsPlugin } from '../getUserActionsPlugin.js';
+import { GraphQL } from '../graphql/GraphQL.js';
+import { makeGettersEnumerable } from '../helpers/makeGettersEnumerable.js';
+import { richtextToString } from '../helpers/richtextToString.js';
+import { getCustomPostRichTextFallback } from '../helpers/textFallbackToRichtext.js';
+import { Comment } from './Comment.js';
+import { Listing } from './Listing.js';
+import { ModNote } from './ModNote.js';
+import { User } from './User.js';
+const SetCustomPostPreviewRequestBodyType = {
+    NONE: 0,
+    BLOCKS: 1,
+    UNRECOGNIZED: -1,
+};
+export const GalleryMediaStatus = {
+    UNKNOWN: 0,
+    VALID: 1,
+    FAILED: 2,
+};
+export class Post {
+    /**
+     * @internal
+     */
+    constructor(data) {
+        _Post_id.set(this, void 0);
+        _Post_authorId.set(this, void 0);
+        _Post_authorName.set(this, void 0);
+        _Post_createdAt.set(this, void 0);
+        _Post_subredditId.set(this, void 0);
+        _Post_subredditName.set(this, void 0);
+        _Post_permalink.set(this, void 0);
+        _Post_title.set(this, void 0);
+        _Post_body.set(this, void 0);
+        _Post_bodyHtml.set(this, void 0);
+        _Post_url.set(this, void 0);
+        _Post_score.set(this, void 0);
+        _Post_numberOfComments.set(this, void 0);
+        _Post_numberOfReports.set(this, void 0);
+        _Post_thumbnail.set(this, void 0);
+        _Post_approved.set(this, void 0);
+        _Post_approvedAtUtc.set(this, void 0);
+        _Post_bannedAtUtc.set(this, void 0);
+        _Post_spam.set(this, void 0);
+        _Post_stickied.set(this, void 0);
+        _Post_removed.set(this, void 0);
+        _Post_removedBy.set(this, void 0);
+        _Post_removedByCategory.set(this, void 0);
+        _Post_archived.set(this, void 0);
+        _Post_edited.set(this, void 0);
+        _Post_locked.set(this, void 0);
+        _Post_nsfw.set(this, void 0);
+        _Post_quarantined.set(this, void 0);
+        _Post_spoiler.set(this, void 0);
+        _Post_hidden.set(this, void 0);
+        _Post_ignoringReports.set(this, void 0);
+        _Post_distinguishedBy.set(this, void 0);
+        _Post_flair.set(this, void 0);
+        _Post_secureMedia.set(this, void 0);
+        _Post_modReportReasons.set(this, void 0);
+        _Post_userReportReasons.set(this, void 0);
+        _Post_gallery.set(this, void 0);
+        makeGettersEnumerable(this);
+        assertNonNull(data.id, 'Post is missing id');
+        assertNonNull(data.title, 'Post is missing title');
+        assertNonNull(data.createdUtc, 'Post is missing created date');
+        assertNonNull(data.author, 'Post is missing author name');
+        assertNonNull(data.subreddit, 'Post is missing subreddit name');
+        assertNonNull(data.subredditId, 'Post is missing subreddit id');
+        assertNonNull(data.url, 'Post is missing url');
+        assertNonNull(data.permalink, 'Post is missing permalink');
+        __classPrivateFieldSet(this, _Post_id, asT3ID(`t3_${data.id}`), "f");
+        __classPrivateFieldSet(this, _Post_authorName, data.author, "f");
+        __classPrivateFieldSet(this, _Post_authorId, data.authorFullname ? asT2ID(data.authorFullname) : undefined, "f");
+        __classPrivateFieldSet(this, _Post_subredditId, asT5ID(data.subredditId), "f");
+        __classPrivateFieldSet(this, _Post_subredditName, data.subreddit, "f");
+        __classPrivateFieldSet(this, _Post_score, data.score ?? 0, "f");
+        __classPrivateFieldSet(this, _Post_numberOfComments, data.numComments ?? 0, "f");
+        __classPrivateFieldSet(this, _Post_numberOfReports, data.numReports ?? 0, "f");
+        const createdAt = new Date(0);
+        createdAt.setUTCSeconds(data.createdUtc);
+        __classPrivateFieldSet(this, _Post_createdAt, createdAt, "f");
+        __classPrivateFieldSet(this, _Post_title, data.title, "f");
+        __classPrivateFieldSet(this, _Post_body, data.selftext, "f");
+        __classPrivateFieldSet(this, _Post_bodyHtml, data.selftextHtml, "f");
+        __classPrivateFieldSet(this, _Post_url, data.url, "f");
+        __classPrivateFieldSet(this, _Post_permalink, data.permalink, "f");
+        if (data.thumbnail &&
+            data.thumbnail !== 'self' &&
+            data.thumbnail !== 'nsfw' &&
+            data.thumbnailHeight != null &&
+            data.thumbnailWidth != null) {
+            __classPrivateFieldSet(this, _Post_thumbnail, {
+                url: data.thumbnail,
+                height: data.thumbnailHeight,
+                width: data.thumbnailWidth,
+            }, "f");
+        }
+        __classPrivateFieldSet(this, _Post_approved, data.approved ?? false, "f");
+        __classPrivateFieldSet(this, _Post_approvedAtUtc, data.approvedAtUtc ?? 0, "f");
+        __classPrivateFieldSet(this, _Post_bannedAtUtc, data.bannedAtUtc ?? 0, "f");
+        __classPrivateFieldSet(this, _Post_removed, data.removed ?? false, "f");
+        __classPrivateFieldSet(this, _Post_removedBy, data.removedBy, "f");
+        __classPrivateFieldSet(this, _Post_removedByCategory, data.removedByCategory, "f");
+        __classPrivateFieldSet(this, _Post_spam, data.spam ?? false, "f");
+        __classPrivateFieldSet(this, _Post_stickied, data.stickied ?? false, "f");
+        __classPrivateFieldSet(this, _Post_archived, data.archived ?? false, "f");
+        __classPrivateFieldSet(this, _Post_edited, data.edited ?? false, "f");
+        __classPrivateFieldSet(this, _Post_locked, data.locked ?? false, "f");
+        __classPrivateFieldSet(this, _Post_nsfw, data.over18 ?? false, "f");
+        __classPrivateFieldSet(this, _Post_quarantined, data.quarantine ?? false, "f");
+        __classPrivateFieldSet(this, _Post_spoiler, data.spoiler, "f");
+        __classPrivateFieldSet(this, _Post_hidden, data.hidden ?? false, "f");
+        __classPrivateFieldSet(this, _Post_ignoringReports, data.ignoreReports ?? false, "f");
+        __classPrivateFieldSet(this, _Post_distinguishedBy, data.distinguished, "f");
+        __classPrivateFieldSet(this, _Post_secureMedia, data.secureMedia, "f");
+        __classPrivateFieldSet(this, _Post_modReportReasons, (data.modReports ?? []).map(([reason]) => reason), "f");
+        __classPrivateFieldSet(this, _Post_userReportReasons, (data.userReports ?? []).map(([reason]) => reason), "f");
+        if (data.linkFlairBackgroundColor ||
+            data.linkFlairCssClass ||
+            data.linkFlairText ||
+            data.linkFlairType ||
+            data.linkFlairTemplateId ||
+            data.linkFlairRichtext ||
+            data.linkFlairTextColor) {
+            __classPrivateFieldSet(this, _Post_flair, {
+                backgroundColor: data.linkFlairBackgroundColor,
+                cssClass: data.linkFlairCssClass,
+                text: data.linkFlairText,
+                type: data.linkFlairType,
+                templateId: data.linkFlairTemplateId,
+                // Map linkFlairRichtext[] into the objects with more user-friendly property names
+                richtext: (data.linkFlairRichtext ?? []).map(({ e, t, a, u }) => ({
+                    elementType: e,
+                    text: t,
+                    emojiRef: a,
+                    url: u,
+                })),
+                textColor: data.linkFlairTextColor,
+            }, "f");
+        }
+        if (data.gallery) {
+            __classPrivateFieldSet(this, _Post_gallery, data.gallery.map((item) => ({
+                status: item.status,
+                url: item.url,
+                height: item.height,
+                width: item.width,
+            })), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Post_gallery, [], "f");
+        }
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _Post_id, "f");
+    }
+    get authorId() {
+        return __classPrivateFieldGet(this, _Post_authorId, "f");
+    }
+    get authorName() {
+        return __classPrivateFieldGet(this, _Post_authorName, "f");
+    }
+    get subredditId() {
+        return __classPrivateFieldGet(this, _Post_subredditId, "f");
+    }
+    get subredditName() {
+        return __classPrivateFieldGet(this, _Post_subredditName, "f");
+    }
+    get permalink() {
+        return __classPrivateFieldGet(this, _Post_permalink, "f");
+    }
+    get title() {
+        return __classPrivateFieldGet(this, _Post_title, "f");
+    }
+    get body() {
+        return __classPrivateFieldGet(this, _Post_body, "f");
+    }
+    get bodyHtml() {
+        return __classPrivateFieldGet(this, _Post_bodyHtml, "f");
+    }
+    get url() {
+        return __classPrivateFieldGet(this, _Post_url, "f");
+    }
+    get thumbnail() {
+        return __classPrivateFieldGet(this, _Post_thumbnail, "f");
+    }
+    get createdAt() {
+        return __classPrivateFieldGet(this, _Post_createdAt, "f");
+    }
+    get score() {
+        return __classPrivateFieldGet(this, _Post_score, "f");
+    }
+    get numberOfComments() {
+        return __classPrivateFieldGet(this, _Post_numberOfComments, "f");
+    }
+    get numberOfReports() {
+        return __classPrivateFieldGet(this, _Post_numberOfReports, "f");
+    }
+    get approved() {
+        return __classPrivateFieldGet(this, _Post_approved, "f");
+    }
+    get approvedAtUtc() {
+        return __classPrivateFieldGet(this, _Post_approvedAtUtc, "f");
+    }
+    get bannedAtUtc() {
+        return __classPrivateFieldGet(this, _Post_bannedAtUtc, "f");
+    }
+    get spam() {
+        return __classPrivateFieldGet(this, _Post_spam, "f");
+    }
+    get stickied() {
+        return __classPrivateFieldGet(this, _Post_stickied, "f");
+    }
+    get removed() {
+        return __classPrivateFieldGet(this, _Post_removed, "f");
+    }
+    /**
+     * Who removed this object (username)
+     */
+    get removedBy() {
+        return __classPrivateFieldGet(this, _Post_removedBy, "f");
+    }
+    /**
+     * who/what removed this object. It will return one of the following:
+     * - "anti_evil_ops": object is removed by a aeops member
+     * - "author": object is removed by author of the post
+     * - "automod_filtered": object is filtered by automod
+     * - "community_ops": object is removed by a community team member
+     * - "content_takedown": object is removed due to content violation
+     * - "copyright_takedown": object is removed due to copyright violation
+     * - "deleted": object is deleted
+     * - "moderator": object is removed by a mod of the sub
+     * - "reddit": object is removed by anyone else
+     * - undefined: object is not removed
+     */
+    get removedByCategory() {
+        return __classPrivateFieldGet(this, _Post_removedByCategory, "f");
+    }
+    get archived() {
+        return __classPrivateFieldGet(this, _Post_archived, "f");
+    }
+    get edited() {
+        return __classPrivateFieldGet(this, _Post_edited, "f");
+    }
+    get locked() {
+        return __classPrivateFieldGet(this, _Post_locked, "f");
+    }
+    get nsfw() {
+        return __classPrivateFieldGet(this, _Post_nsfw, "f");
+    }
+    get quarantined() {
+        return __classPrivateFieldGet(this, _Post_quarantined, "f");
+    }
+    get spoiler() {
+        return __classPrivateFieldGet(this, _Post_spoiler, "f");
+    }
+    get hidden() {
+        return __classPrivateFieldGet(this, _Post_hidden, "f");
+    }
+    get ignoringReports() {
+        return __classPrivateFieldGet(this, _Post_ignoringReports, "f");
+    }
+    get distinguishedBy() {
+        return __classPrivateFieldGet(this, _Post_distinguishedBy, "f");
+    }
+    get comments() {
+        return Comment.getComments({
+            postId: this.id,
+        });
+    }
+    get flair() {
+        return __classPrivateFieldGet(this, _Post_flair, "f");
+    }
+    get secureMedia() {
+        return __classPrivateFieldGet(this, _Post_secureMedia, "f");
+    }
+    get userReportReasons() {
+        return __classPrivateFieldGet(this, _Post_userReportReasons, "f");
+    }
+    get modReportReasons() {
+        return __classPrivateFieldGet(this, _Post_modReportReasons, "f");
+    }
+    /**
+     * Get the media in the post. Empty if the post doesn't have any media.
+     */
+    get gallery() {
+        return __classPrivateFieldGet(this, _Post_gallery, "f");
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            authorId: this.authorId,
+            authorName: this.authorName,
+            subredditId: this.subredditId,
+            subredditName: this.subredditName,
+            permalink: this.permalink,
+            title: this.title,
+            body: this.body,
+            bodyHtml: this.bodyHtml,
+            url: this.url,
+            thumbnail: this.thumbnail,
+            score: this.score,
+            numberOfComments: this.numberOfComments,
+            numberOfReports: this.numberOfReports,
+            createdAt: this.createdAt,
+            approved: this.approved,
+            spam: this.spam,
+            stickied: this.stickied,
+            removed: this.removed,
+            removedBy: __classPrivateFieldGet(this, _Post_removedBy, "f"),
+            removedByCategory: __classPrivateFieldGet(this, _Post_removedByCategory, "f"),
+            archived: this.archived,
+            edited: this.edited,
+            locked: this.locked,
+            nsfw: this.nsfw,
+            quarantined: this.quarantined,
+            spoiler: this.spoiler,
+            hidden: this.hidden,
+            ignoringReports: this.ignoringReports,
+            distinguishedBy: this.distinguishedBy,
+            flair: this.flair,
+            secureMedia: this.secureMedia,
+            modReportReasons: __classPrivateFieldGet(this, _Post_modReportReasons, "f"),
+            userReportReasons: __classPrivateFieldGet(this, _Post_userReportReasons, "f"),
+        };
+    }
+    isApproved() {
+        return __classPrivateFieldGet(this, _Post_approved, "f");
+    }
+    isSpam() {
+        return __classPrivateFieldGet(this, _Post_spam, "f");
+    }
+    isStickied() {
+        return __classPrivateFieldGet(this, _Post_stickied, "f");
+    }
+    isRemoved() {
+        return __classPrivateFieldGet(this, _Post_removed, "f");
+    }
+    isArchived() {
+        return __classPrivateFieldGet(this, _Post_archived, "f");
+    }
+    isEdited() {
+        return __classPrivateFieldGet(this, _Post_edited, "f");
+    }
+    isLocked() {
+        return __classPrivateFieldGet(this, _Post_locked, "f");
+    }
+    isNsfw() {
+        return __classPrivateFieldGet(this, _Post_nsfw, "f");
+    }
+    isQuarantined() {
+        return __classPrivateFieldGet(this, _Post_quarantined, "f");
+    }
+    isSpoiler() {
+        return __classPrivateFieldGet(this, _Post_spoiler, "f");
+    }
+    isHidden() {
+        return __classPrivateFieldGet(this, _Post_hidden, "f");
+    }
+    isIgnoringReports() {
+        return __classPrivateFieldGet(this, _Post_ignoringReports, "f");
+    }
+    isDistinguishedBy() {
+        return __classPrivateFieldGet(this, _Post_distinguishedBy, "f");
+    }
+    async edit(options) {
+        const newPost = await _a.edit({
+            id: this.id,
+            ...options,
+        });
+        __classPrivateFieldSet(this, _Post_body, newPost.body, "f");
+        __classPrivateFieldSet(this, _Post_edited, newPost.edited, "f");
+    }
+    /**
+     * Set the suggested sort for comments on a Post.
+     *
+     * @throws {Error} Throws an error if the suggested sort could not be set.
+     * @example
+     * ```ts
+     * const post = await reddit.getPostById(context.postId);
+     * await post.setSuggestedCommentSort("NEW");
+     * ```
+     */
+    async setSuggestedCommentSort(suggestedSort) {
+        await _a.setSuggestedCommentSort({
+            id: this.id,
+            subredditId: __classPrivateFieldGet(this, _Post_subredditId, "f"),
+            suggestedSort,
+        });
+    }
+    /**
+     * Set a lightweight UI that shows while the custom post renders
+     *
+     * @param {JSX.ComponentFunction} ui - A JSX component function that returns a simple ui to be rendered.
+     * @throws {Error} Throws an error if the preview could not be set.
+     * @example
+     * ```ts
+     * const preview = (
+     *   <vstack height="100%" width="100%" alignment="middle center">
+     *     <text size="large">An updated preview!</text>
+     *   </vstack>
+     * );
+     * const post = await reddit.getPostById(context.postId);
+     * await post.setCustomPostPreview(() => preview);
+     * ```
+     */
+    async setCustomPostPreview(ui) {
+        await _a.setCustomPostPreview({
+            id: this.id,
+            ui,
+        });
+    }
+    /**
+     * Set a text fallback for the custom post
+     *
+     * @param {CustomPostTextFallbackOptions} options - A text or a richtext to render in a fallback
+     * @throws {Error} Throws an error if the fallback could not be set.
+     * @example
+     * ```ts
+     * // from a menu action, form, scheduler, trigger, custom post click event, etc
+     * const newTextFallback = { text: 'This is an updated text fallback' };
+     * const post = await context.reddit.getPostById(context.postId);
+     * await post.setTextFallback(newTextFallback);
+     * ```
+     */
+    async setTextFallback(options) {
+        const newPost = await _a.setTextFallback(options, this.id);
+        __classPrivateFieldSet(this, _Post_body, newPost.body, "f");
+        __classPrivateFieldSet(this, _Post_edited, newPost.edited, "f");
+    }
+    async addComment(options) {
+        return Comment.submit({
+            id: this.id,
+            ...options,
+        });
+    }
+    async delete() {
+        const appUsername = getContext().appName;
+        if (appUsername !== __classPrivateFieldGet(this, _Post_authorName, "f")) {
+            throw new Error(`App '${appUsername}' is not the author of Post ${this.id}, delete not allowed.`);
+        }
+        return _a.delete(this.id);
+    }
+    async approve() {
+        await _a.approve(this.id);
+        __classPrivateFieldSet(this, _Post_approved, true, "f");
+        __classPrivateFieldSet(this, _Post_removed, false, "f");
+    }
+    async remove(isSpam = false) {
+        await _a.remove(this.id, isSpam);
+        __classPrivateFieldSet(this, _Post_removed, true, "f");
+        __classPrivateFieldSet(this, _Post_spam, isSpam, "f");
+        __classPrivateFieldSet(this, _Post_approved, false, "f");
+    }
+    async lock() {
+        await _a.lock(this.id);
+        __classPrivateFieldSet(this, _Post_locked, true, "f");
+    }
+    async unlock() {
+        await _a.unlock(this.id);
+        __classPrivateFieldSet(this, _Post_locked, false, "f");
+    }
+    async hide() {
+        await _a.hide(this.id);
+        __classPrivateFieldSet(this, _Post_hidden, true, "f");
+    }
+    async unhide() {
+        await _a.unhide(this.id);
+        __classPrivateFieldSet(this, _Post_hidden, false, "f");
+    }
+    async markAsNsfw() {
+        await _a.markAsNsfw(this.id);
+        __classPrivateFieldSet(this, _Post_nsfw, true, "f");
+    }
+    async unmarkAsNsfw() {
+        await _a.unmarkAsNsfw(this.id);
+        __classPrivateFieldSet(this, _Post_nsfw, false, "f");
+    }
+    async markAsSpoiler() {
+        await _a.markAsSpoiler(this.id);
+        __classPrivateFieldSet(this, _Post_spoiler, true, "f");
+    }
+    async unmarkAsSpoiler() {
+        await _a.unmarkAsSpoiler(this.id);
+        __classPrivateFieldSet(this, _Post_spoiler, false, "f");
+    }
+    async sticky(position) {
+        await _a.sticky(this.id, position);
+    }
+    async unsticky() {
+        await _a.unsticky(this.id);
+    }
+    async distinguish() {
+        const { distinguishedBy } = await _a.distinguish(this.id, false);
+        __classPrivateFieldSet(this, _Post_distinguishedBy, distinguishedBy, "f");
+    }
+    async distinguishAsAdmin() {
+        const { distinguishedBy } = await _a.distinguish(this.id, true);
+        __classPrivateFieldSet(this, _Post_distinguishedBy, distinguishedBy, "f");
+    }
+    async undistinguish() {
+        const { distinguishedBy } = await _a.undistinguish(this.id);
+        __classPrivateFieldSet(this, _Post_distinguishedBy, distinguishedBy, "f");
+    }
+    async ignoreReports() {
+        await _a.ignoreReports(this.id);
+        __classPrivateFieldSet(this, _Post_ignoringReports, true, "f");
+    }
+    async unignoreReports() {
+        await _a.unignoreReports(this.id);
+        __classPrivateFieldSet(this, _Post_ignoringReports, false, "f");
+    }
+    async getAuthor() {
+        return User.getByUsername(__classPrivateFieldGet(this, _Post_authorName, "f"));
+    }
+    async crosspost(options) {
+        return _a.crosspost({
+            ...options,
+            postId: this.id,
+        });
+    }
+    /**
+     * Add a mod note for why the post was removed
+     *
+     * @param options.reasonId id of a Removal Reason - you can leave this as an empty string if you don't have one
+     * @param options.modNote the reason for removal (maximum 100 characters) (optional)
+     * @returns
+     */
+    addRemovalNote(options) {
+        return ModNote.addRemovalNote({ itemIds: [__classPrivateFieldGet(this, _Post_id, "f")], ...options });
+    }
+    /**
+     * Get a thumbnail that contains a preview image and also contains a blurred preview for
+     * NSFW images. The thumbnail returned has higher resolution than Post.thumbnail.
+     * Returns undefined if the post doesn't have a thumbnail
+     *
+     * @returns {EnrichedThumbnail | undefined}
+     * @throws {Error} Throws an error if the thumbnail could not be fetched
+     * @example
+     * ```ts
+     * // from a menu action, form, scheduler, trigger, custom post click event, etc
+     * const post = await context.reddit.getPostById(context.postId);
+     * const enrichedThumbnail = await post.getEnrichedThumbnail();
+     * ```
+     */
+    async getEnrichedThumbnail() {
+        return getThumbnailV2({ id: this.id });
+    }
+    // TODO: flair methods
+    /** @internal */
+    static async getById(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        const postId = isT3ID(id) ? id : `t3_${id}`;
+        const response = await client.Info({
+            subreddits: [],
+            thingIds: [postId],
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        if (!response.data?.children?.length) {
+            throw new Error('could not find post');
+        }
+        const postData = response.data.children[0];
+        if (!postData?.data) {
+            throw new Error('could not find post');
+        }
+        return new _a(postData.data);
+    }
+    /** @internal */
+    static async submit(options) {
+        const { runAs = 'APP' } = options;
+        const runAsType = RunAs[runAs];
+        const client = runAsType === RunAs.USER ? getUserActionsPlugin() : getRedditApiPlugins().LinksAndComments;
+        let response;
+        if ('preview' in options) {
+            if (runAsType === RunAs.USER) {
+                assertNonNull(options.userGeneratedContent, 'userGeneratedContent must be set in `SubmitPostOptions` when RunAs=USER for experience posts');
+            }
+            const reconciler = new BlocksReconciler(() => options.preview, undefined, {}, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get), undefined);
+            const previewBlock = await reconciler.buildBlocksUI();
+            const encodedCached = Block.encode(previewBlock).finish();
+            const { textFallback, ...sanitizedOptions } = options;
+            const richtextFallback = textFallback ? getCustomPostRichTextFallback(textFallback) : '';
+            const userGeneratedContent = options.userGeneratedContent
+                ? {
+                    text: options.userGeneratedContent.text ?? '',
+                    imageUrls: options.userGeneratedContent.imageUrls ?? [],
+                }
+                : undefined;
+            const submitRequest = {
+                kind: 'custom',
+                sr: options.subredditName,
+                richtextJson: Buffer.from(encodedCached).toString('base64'),
+                richtextFallback,
+                ...sanitizedOptions,
+                userGeneratedContent,
+                runAs: runAsType,
+            };
+            response = await client.SubmitCustomPost(submitRequest, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        }
+        else {
+            response = await client.Submit({
+                kind: 'kind' in options ? options.kind : 'url' in options ? 'link' : 'self',
+                sr: options.subredditName,
+                richtextJson: 'richtext' in options ? richtextToString(options.richtext) : undefined,
+                ...options,
+                runAs: runAsType,
+            }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        }
+        // Post Id might not be present as image/video post creation can happen asynchronously
+        const isAllowedMediaType = 'kind' in options && ['image', 'video', 'videogif'].includes(options.kind);
+        if (isAllowedMediaType && !response.json?.data?.id) {
+            if (options.kind === 'image' && 'imageUrls' in options) {
+                throw new Error(`Image post type with ${options.imageUrls} is being created asynchronously and should be updated in the subreddit soon.`);
+            }
+            else if ('videoPosterUrl' in options) {
+                throw new Error(`Post of ${options.kind} type with ${options.videoPosterUrl} is being created asynchronously and should be updated in the subreddit soon.`);
+            }
+        }
+        if (!response.json?.data?.id || response.json?.errors?.length) {
+            throw new Error(`failed to submit post - either post ID is empty or request failed with errors: ${response.json?.errors}`);
+        }
+        return _a.getById(`t3_${response.json.data.id}`);
+    }
+    /** @internal */
+    static async crosspost(options) {
+        const { runAs = 'APP' } = options;
+        const runAsType = RunAs[runAs];
+        const client = runAsType === RunAs.USER ? getUserActionsPlugin() : getRedditApiPlugins().LinksAndComments;
+        const { postId, subredditName, ...rest } = options;
+        const response = await client.Submit({
+            kind: 'crosspost',
+            sr: subredditName,
+            crosspostFullname: asT3ID(postId),
+            ...rest,
+            runAs: runAsType,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        if (!response.json?.data?.id || response.json?.errors?.length) {
+            throw new Error('failed to crosspost post');
+        }
+        return _a.getById(`t3_${response.json.data.id}`);
+    }
+    /** @internal */
+    static async edit(options) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        const { id } = options;
+        let richtextString;
+        if ('richtext' in options) {
+            richtextString = richtextToString(options.richtext);
+        }
+        const response = await client.EditUserText({
+            thingId: id,
+            text: 'text' in options ? options.text : '',
+            richtextJson: richtextString,
+            runAs: RunAs.APP,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        if (response.json?.errors?.length) {
+            throw new Error('Failed to edit post');
+        }
+        // The LinksAndComments.EditUserText response is wrong and assumes that
+        // the API is only used to for comments so we fetch the new post here.
+        return _a.getById(id);
+    }
+    /** @internal */
+    static async setSuggestedCommentSort(options) {
+        const operationName = 'SetSuggestedSort';
+        const persistedQueryHash = 'cf6052acc7fefaa65b710625b81dba8041f258313aafe9730e2a3dc855e5d10d';
+        const response = await GraphQL.query(operationName, persistedQueryHash, {
+            input: {
+                subredditId: options.subredditId,
+                postId: options.id,
+                sort: options.suggestedSort,
+            },
+        });
+        if (!response.data?.setSuggestedSort?.ok) {
+            throw new Error('Failed to set suggested sort');
+        }
+    }
+    /** @internal */
+    static async setCustomPostPreview(options) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        const handler = new BlocksHandler(options.ui);
+        const handlerResponse = UIResponse.fromJSON(await handler.handle({ events: [] }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get)));
+        const block = handlerResponse.blocks;
+        const blocksRenderContent = Buffer.from(Block.encode(block).finish()).toString('base64');
+        await client.SetCustomPostPreview({
+            thingId: options.id,
+            bodyType: SetCustomPostPreviewRequestBodyType.BLOCKS,
+            blocksRenderContent,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async setTextFallback(options, postId) {
+        if (!('text' in options) && !('richtext' in options)) {
+            throw new Error(`No text fallback provided for post ${postId}.`);
+        }
+        const client = getRedditApiPlugins().LinksAndComments;
+        const richtextFallback = getCustomPostRichTextFallback(options);
+        const response = await client.EditCustomPost({
+            thingId: postId,
+            richtextFallback,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        if (response.json?.errors?.length) {
+            throw new Error('Failed to set post text fallback');
+        }
+        return _a.getById(postId);
+    }
+    /** @internal */
+    static async delete(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Del({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async approve(id) {
+        const client = getRedditApiPlugins().Moderation;
+        await client.Approve({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async remove(id, isSpam = false) {
+        const client = getRedditApiPlugins().Moderation;
+        await client.Remove({
+            id,
+            spam: isSpam,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async hide(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Hide({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async unhide(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Unhide({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async markAsNsfw(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.MarkNSFW({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async unmarkAsNsfw(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.UnmarkNSFW({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async markAsSpoiler(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Spoiler({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async unmarkAsSpoiler(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Unspoiler({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async sticky(id, position) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.SetSubredditSticky({
+            id,
+            state: true,
+            num: position,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async unsticky(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.SetSubredditSticky({
+            id,
+            state: false,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async lock(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Lock({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async unlock(id) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        await client.Unlock({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async distinguish(id, asAdmin) {
+        const client = getRedditApiPlugins().Moderation;
+        const response = await client.Distinguish({
+            id,
+            how: asAdmin ? 'admin' : 'yes',
+            sticky: false,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        const post = response.json?.data?.things?.[0]?.data;
+        assertNonNull(post);
+        return {
+            distinguishedBy: post.distinguished,
+        };
+    }
+    /** @internal */
+    static async undistinguish(id) {
+        const client = getRedditApiPlugins().Moderation;
+        const response = await client.Distinguish({
+            id,
+            how: 'no',
+            sticky: false,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+        const post = response.json?.data?.things?.[0]?.data;
+        assertNonNull(post);
+        return {
+            distinguishedBy: post.distinguished,
+        };
+    }
+    /** @internal */
+    static async ignoreReports(id) {
+        const client = getRedditApiPlugins().Moderation;
+        await client.IgnoreReports({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static async unignoreReports(id) {
+        const client = getRedditApiPlugins().Moderation;
+        await client.UnignoreReports({
+            id,
+        }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+    }
+    /** @internal */
+    static getControversialPosts(options = {}) {
+        return this.getSortedPosts({
+            ...options,
+            sort: 'controversial',
+        });
+    }
+    /** @internal */
+    static getTopPosts(options = {}) {
+        return this.getSortedPosts({
+            ...options,
+            sort: 'top',
+        });
+    }
+    /** @internal */
+    static getSortedPosts(options) {
+        const client = getRedditApiPlugins().Listings;
+        return new Listing({
+            hasMore: true,
+            before: options.before,
+            after: options.after,
+            pageSize: options.pageSize,
+            limit: options.limit,
+            fetch: async (fetchOptions) => {
+                const response = await client.Sort({
+                    show: 'all',
+                    sort: options.sort,
+                    t: options.timeframe,
+                    subreddit: options.subredditName,
+                    ...fetchOptions,
+                }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+                return listingProtosToPosts(response);
+            },
+        });
+    }
+    /** @internal */
+    static getHotPosts(options = {
+        location: 'GLOBAL',
+    }) {
+        const client = getRedditApiPlugins().Listings;
+        return new Listing({
+            hasMore: true,
+            before: options.before,
+            after: options.after,
+            pageSize: options.pageSize,
+            limit: options.limit,
+            fetch: async (fetchOptions) => {
+                const response = await client.Hot({
+                    g: options.location,
+                    show: 'all',
+                    subreddit: options.subredditName,
+                    ...fetchOptions,
+                }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+                return listingProtosToPosts(response);
+            },
+        });
+    }
+    /** @internal */
+    static getNewPosts(options) {
+        const client = getRedditApiPlugins().Listings;
+        return new Listing({
+            hasMore: true,
+            before: options.before,
+            after: options.after,
+            pageSize: options.pageSize,
+            limit: options.limit,
+            fetch: async (fetchOptions) => {
+                const response = await client.New({
+                    show: 'all',
+                    subreddit: options.subredditName,
+                    ...fetchOptions,
+                }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+                return listingProtosToPosts(response);
+            },
+        });
+    }
+    /** @internal */
+    static getRisingPosts(options) {
+        const client = getRedditApiPlugins().Listings;
+        return new Listing({
+            hasMore: true,
+            before: options.before,
+            after: options.after,
+            pageSize: options.pageSize,
+            limit: options.limit,
+            fetch: async (fetchOptions) => {
+                const response = await client.Rising({
+                    show: 'all',
+                    subreddit: options.subredditName,
+                    ...fetchOptions,
+                }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+                return listingProtosToPosts(response);
+            },
+        });
+    }
+    /** @internal */
+    static getPostsByUser(options) {
+        const client = getRedditApiPlugins().Users;
+        return new Listing({
+            hasMore: true,
+            before: options.before,
+            after: options.after,
+            pageSize: options.pageSize,
+            limit: options.limit,
+            fetch: async (fetchOptions) => {
+                const response = await client.UserWhere({
+                    username: options.username,
+                    where: 'submitted',
+                    ...fetchOptions,
+                }, __classPrivateFieldGet(this, _a, "a", _Post_metadata_get));
+                return listingProtosToPosts(response);
+            },
+        });
+    }
+}
+_a = Post, _Post_id = new WeakMap(), _Post_authorId = new WeakMap(), _Post_authorName = new WeakMap(), _Post_createdAt = new WeakMap(), _Post_subredditId = new WeakMap(), _Post_subredditName = new WeakMap(), _Post_permalink = new WeakMap(), _Post_title = new WeakMap(), _Post_body = new WeakMap(), _Post_bodyHtml = new WeakMap(), _Post_url = new WeakMap(), _Post_score = new WeakMap(), _Post_numberOfComments = new WeakMap(), _Post_numberOfReports = new WeakMap(), _Post_thumbnail = new WeakMap(), _Post_approved = new WeakMap(), _Post_approvedAtUtc = new WeakMap(), _Post_bannedAtUtc = new WeakMap(), _Post_spam = new WeakMap(), _Post_stickied = new WeakMap(), _Post_removed = new WeakMap(), _Post_removedBy = new WeakMap(), _Post_removedByCategory = new WeakMap(), _Post_archived = new WeakMap(), _Post_edited = new WeakMap(), _Post_locked = new WeakMap(), _Post_nsfw = new WeakMap(), _Post_quarantined = new WeakMap(), _Post_spoiler = new WeakMap(), _Post_hidden = new WeakMap(), _Post_ignoringReports = new WeakMap(), _Post_distinguishedBy = new WeakMap(), _Post_flair = new WeakMap(), _Post_secureMedia = new WeakMap(), _Post_modReportReasons = new WeakMap(), _Post_userReportReasons = new WeakMap(), _Post_gallery = new WeakMap(), _Post_metadata_get = function _Post_metadata_get() {
+    return getContext().debug.metadata;
+};
+function listingProtosToPosts(listingProto) {
+    if (!listingProto.data?.children) {
+        throw new Error('Listing response is missing children');
+    }
+    const children = listingProto.data.children.map((child) => new Post(child.data));
+    return {
+        children,
+        before: listingProto.data.before,
+        after: listingProto.data.after,
+    };
+}
+/** @internal */
+async function getThumbnailV2(options) {
+    const operationName = 'GetThumbnailV2';
+    const persistedQueryHash = '81580ce4e23d748c5a59a1618489b559bf4518b6a73af41f345d8d074c8b2ce9';
+    const response = await GraphQL.query(operationName, persistedQueryHash, {
+        id: options.id,
+    });
+    const thumbnail = response.data?.postInfoById?.thumbnailV2;
+    if (!thumbnail) {
+        throw new Error('Failed to get thumbnail');
+    }
+    else if (!thumbnail.image) {
+        return undefined;
+    }
+    return {
+        attribution: thumbnail.attribution,
+        image: {
+            url: thumbnail.image.url,
+            width: thumbnail.image.dimensions.width,
+            height: thumbnail.image.dimensions.height,
+        },
+        isObfuscatedDefault: thumbnail.isObfuscatedDefault,
+        ...(thumbnail.obfuscatedImage && {
+            obfuscatedImage: {
+                url: thumbnail.obfuscatedImage.url,
+                width: thumbnail.obfuscatedImage.dimensions.width,
+                height: thumbnail.obfuscatedImage.dimensions.height,
+            },
+        }),
+    };
+}