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

package/models/Subreddit.js

@@ -0,0 +1,750 @@
+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, _Subreddit_id, _Subreddit_name, _Subreddit_createdAt, _Subreddit_type, _Subreddit_title, _Subreddit_description, _Subreddit_language, _Subreddit_numberOfSubscribers, _Subreddit_numberOfActiveUsers, _Subreddit_nsfw, _Subreddit_settings, _Subreddit_permalink, _Subreddit_metadata_get;
+import { getContext } from '@devvit/server';
+import { assertNonNull } from '@devvit/shared-types/NonNull.js';
+import { asT5ID } from '@devvit/shared-types/tid.js';
+import { getRedditApiPlugins } from '../getRedditApiPlugins.js';
+import { GraphQL } from '../graphql/GraphQL.js';
+import { makeGettersEnumerable } from '../helpers/makeGettersEnumerable.js';
+import { Comment } from './Comment.js';
+import { convertUserFlairProtoToAPI, Flair, FlairTemplate } from './Flair.js';
+import { Listing } from './Listing.js';
+import { getModerationLog } from './ModAction.js';
+import { Post } from './Post.js';
+import { User } from './User.js';
+export var AboutLocations;
+(function (AboutLocations) {
+    AboutLocations["Reports"] = "reports";
+    AboutLocations["Spam"] = "spam";
+    AboutLocations["Modqueue"] = "modqueue";
+    AboutLocations["Unmoderated"] = "unmoderated";
+    AboutLocations["Edited"] = "edited";
+})(AboutLocations || (AboutLocations = {}));
+export class SubredditDescription {
+}
+export class SubredditWikiSettings {
+}
+export class AuthorFlairSettings {
+}
+export class PostFlairSettings {
+}
+/**
+ * A class representing a subreddit.
+ */
+export class Subreddit {
+    /**
+     * @internal
+     */
+    constructor(data) {
+        _Subreddit_id.set(this, void 0);
+        _Subreddit_name.set(this, void 0);
+        _Subreddit_createdAt.set(this, void 0);
+        _Subreddit_type.set(this, void 0);
+        _Subreddit_title.set(this, void 0);
+        _Subreddit_description.set(this, void 0);
+        _Subreddit_language.set(this, void 0);
+        _Subreddit_numberOfSubscribers.set(this, void 0);
+        _Subreddit_numberOfActiveUsers.set(this, void 0);
+        _Subreddit_nsfw.set(this, void 0);
+        _Subreddit_settings.set(this, void 0);
+        // R2 bug: subreddit does not contain a permalink field, but uses the url field instead
+        _Subreddit_permalink.set(this, void 0);
+        makeGettersEnumerable(this);
+        assertNonNull(data.id, 'Subreddit id is missing or undefined');
+        assertNonNull(data.displayName, 'Subreddit name is missing or undefined');
+        __classPrivateFieldSet(this, _Subreddit_id, asT5ID(`t5_${data.id}`), "f");
+        __classPrivateFieldSet(this, _Subreddit_name, data.displayName, "f");
+        assertNonNull(data.createdUtc, 'Subreddit is missing created date');
+        const createdAt = new Date(0);
+        createdAt.setUTCSeconds(data.createdUtc);
+        __classPrivateFieldSet(this, _Subreddit_createdAt, createdAt, "f");
+        __classPrivateFieldSet(this, _Subreddit_type, asSubredditType(data.subredditType), "f");
+        __classPrivateFieldSet(this, _Subreddit_title, data.title, "f");
+        __classPrivateFieldSet(this, _Subreddit_description, data.description, "f");
+        assertNonNull(data.lang, 'Subreddit is missing language');
+        __classPrivateFieldSet(this, _Subreddit_language, data.lang, "f");
+        __classPrivateFieldSet(this, _Subreddit_numberOfSubscribers, data.subscribers ?? 0, "f");
+        __classPrivateFieldSet(this, _Subreddit_numberOfActiveUsers, data.activeUserCount ?? 0, "f");
+        __classPrivateFieldSet(this, _Subreddit_nsfw, data.over18 ?? false, "f");
+        __classPrivateFieldSet(this, _Subreddit_permalink, data.url ?? '', "f");
+        __classPrivateFieldSet(this, _Subreddit_settings, {
+            acceptFollowers: data.acceptFollowers ?? false,
+            allOriginalContent: data.allOriginalContent ?? false,
+            allowChatPostCreation: data.allowChatPostCreation ?? false,
+            allowDiscovery: data.allowDiscovery ?? false,
+            allowGalleries: data.allowGalleries ?? false,
+            allowImages: data.allowImages ?? false,
+            allowPolls: data.allowPolls ?? false,
+            allowPredictionContributors: data.allowPredictionContributors ?? false,
+            allowPredictions: data.allowPredictions ?? false,
+            allowPredictionsTournament: data.allowPredictionsTournament ?? false,
+            allowTalks: data.allowTalks ?? false,
+            allowVideoGifs: data.allowVideogifs ?? false,
+            allowVideos: data.allowVideos ?? false,
+            chatPostEnabled: data.isChatPostFeatureEnabled ?? false,
+            collectionsEnabled: data.collectionsEnabled ?? false,
+            crosspostable: data.isCrosspostableSubreddit ?? false,
+            emojisEnabled: data.emojisEnabled ?? false,
+            eventPostsEnabled: data.eventPostsEnabled ?? false,
+            linkFlairEnabled: data.linkFlairEnabled ?? false,
+            originalContentTagEnabled: data.originalContentTagEnabled ?? false,
+            restrictCommenting: data.restrictCommenting ?? false,
+            restrictPosting: data.restrictPosting ?? false,
+            shouldArchivePosts: data.shouldArchivePosts ?? false,
+            spoilersEnabled: data.spoilersEnabled ?? false,
+            wikiEnabled: data.wikiEnabled ?? false,
+            allowedPostType: asAllowedPostType(data.submissionType),
+            allowedMediaInComments: (data.allowedMediaInComments ?? []).map(asCommentMediaTypes),
+            bannerBackgroundColor: data.bannerBackgroundColor,
+            bannerBackgroundImage: data.bannerBackgroundImage,
+            bannerImage: data.bannerImg,
+            communityIcon: data.communityIcon,
+            headerTitle: data.headerTitle,
+            keyColor: data.keyColor,
+            mobileBannerImage: data.mobileBannerImage,
+            primaryColor: data.primaryColor,
+            userFlairs: {
+                enabled: data.userFlairEnabledInSr ?? false,
+                usersCanAssign: data.canAssignUserFlair ?? false,
+                userFlairBackgroundColor: data.userFlairBackgroundColor,
+                userFlairTextColor: data.userFlairTextColor,
+            },
+            postFlairs: {
+                enabled: data.linkFlairEnabled ?? false,
+                usersCanAssign: data.canAssignLinkFlair ?? false,
+            },
+            // R2 bug: url is a permalink
+            url: new URL(__classPrivateFieldGet(this, _Subreddit_permalink, "f"), 'https://www.reddit.com').toString(),
+        }, "f");
+    }
+    /**
+     * The ID (starting with t5_) of the subreddit to retrieve. e.g. t5_2qjpg
+     */
+    get id() {
+        return __classPrivateFieldGet(this, _Subreddit_id, "f");
+    }
+    /**
+     * The name of a subreddit omitting the r/.
+     */
+    get name() {
+        return __classPrivateFieldGet(this, _Subreddit_name, "f");
+    }
+    /**
+     * The creation date of the subreddit.
+     */
+    get createdAt() {
+        return __classPrivateFieldGet(this, _Subreddit_createdAt, "f");
+    }
+    /**
+     * The type of subreddit (public, private, etc.).
+     */
+    get type() {
+        return __classPrivateFieldGet(this, _Subreddit_type, "f");
+    }
+    /**
+     * The title of the subreddit.
+     */
+    get title() {
+        return __classPrivateFieldGet(this, _Subreddit_title, "f");
+    }
+    /**
+     * The description of the subreddit.
+     */
+    get description() {
+        return __classPrivateFieldGet(this, _Subreddit_description, "f");
+    }
+    /**
+     * The language of the subreddit.
+     */
+    get language() {
+        return __classPrivateFieldGet(this, _Subreddit_language, "f");
+    }
+    /**
+     * The number of subscribers of the subreddit.
+     */
+    get numberOfSubscribers() {
+        return __classPrivateFieldGet(this, _Subreddit_numberOfSubscribers, "f");
+    }
+    /**
+     * The number of active users of the subreddit.
+     */
+    get numberOfActiveUsers() {
+        return __classPrivateFieldGet(this, _Subreddit_numberOfActiveUsers, "f");
+    }
+    /**
+     * Whether the subreddit is marked as NSFW (Not Safe For Work).
+     */
+    get nsfw() {
+        return __classPrivateFieldGet(this, _Subreddit_nsfw, "f");
+    }
+    /**
+     * The settings of the subreddit.
+     */
+    get settings() {
+        return __classPrivateFieldGet(this, _Subreddit_settings, "f");
+    }
+    /**
+     * Whether the user flairs are enabled for this subreddit.
+     */
+    get userFlairsEnabled() {
+        return this.settings.userFlairs.enabled;
+    }
+    /**
+     * Whether the post flairs are enabled for this subreddit.
+     */
+    get postFlairsEnabled() {
+        return this.settings.postFlairs.enabled;
+    }
+    /**
+     * Whether the user can assign user flairs.
+     * This is only true if the user flairs are enabled.
+     */
+    get usersCanAssignUserFlairs() {
+        return this.settings.userFlairs.usersCanAssign;
+    }
+    /**
+     * Whether the user can assign post flairs.
+     * This is only true if the post flairs are enabled.
+     */
+    get usersCanAssignPostFlairs() {
+        return this.settings.postFlairs.usersCanAssign;
+    }
+    /**
+     * Returns the HTTP URL for the subreddit.
+     * (R2 bug: subreddit.url is a permalink path and does not return a fully qualified URL in subreddit.url)
+     */
+    get url() {
+        return this.settings.url;
+    }
+    /**
+     * Returns a permalink path
+     * (R2 bug: subreddit.url is a permalink, and does not have a subreddit.permalink field)
+     */
+    get permalink() {
+        return __classPrivateFieldGet(this, _Subreddit_permalink, "f");
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            createdAt: this.createdAt,
+            type: this.type,
+            title: this.title,
+            description: this.description,
+            language: this.language,
+            nsfw: this.nsfw,
+            numberOfSubscribers: this.numberOfSubscribers,
+            numberOfActiveUsers: this.numberOfActiveUsers,
+            settings: this.settings,
+        };
+    }
+    async submitPost(options) {
+        const submitPostOptions = {
+            ...options,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        };
+        return Post.submit(submitPostOptions);
+    }
+    getControversialPosts(options = {}) {
+        if (!__classPrivateFieldGet(this, _Subreddit_name, "f")) {
+            throw new Error('subreddit missing displayName - it might not have been fetched');
+        }
+        return Post.getControversialPosts({
+            ...options,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    getTopPosts(options = {}) {
+        if (!__classPrivateFieldGet(this, _Subreddit_name, "f")) {
+            throw new Error('subreddit missing displayName - it might not have been fetched');
+        }
+        return Post.getTopPosts({
+            ...options,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    getApprovedUsers(options = {}) {
+        return User.getSubredditUsersByType({
+            type: 'contributors',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    approveUser(username) {
+        return User.createRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'contributor',
+        });
+    }
+    removeUser(username) {
+        return User.removeRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'contributor',
+        });
+    }
+    getWikiContributors(options = {}) {
+        return User.getSubredditUsersByType({
+            type: 'wikicontributors',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    addWikiContributor(username) {
+        return User.createRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'wikicontributor',
+        });
+    }
+    removeWikiContributor(username) {
+        return User.removeRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'wikicontributor',
+        });
+    }
+    getBannedUsers(options = {}) {
+        return User.getSubredditUsersByType({
+            type: 'banned',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    banUser(options) {
+        return User.createRelationship({
+            username: options.username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'banned',
+            banReason: options.reason,
+            banMessage: options.message,
+            note: options.note,
+            duration: options.duration,
+            banContext: options.context,
+        });
+    }
+    unbanUser(username) {
+        return User.removeRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'banned',
+        });
+    }
+    getBannedWikiContributors(options = {}) {
+        return User.getSubredditUsersByType({
+            type: 'wikibanned',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    banWikiContributor(options) {
+        return User.createRelationship({
+            username: options.username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'wikibanned',
+            banReason: options.reason,
+            note: options.note,
+            duration: options.duration,
+        });
+    }
+    unbanWikiContributor(username) {
+        return User.removeRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'wikibanned',
+        });
+    }
+    getModerators(options = {}) {
+        return User.getSubredditUsersByType({
+            type: 'moderators',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    inviteModerator(username, permissions) {
+        return User.createRelationship({
+            type: 'moderator_invite',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            username,
+            permissions: permissions ?? [],
+        });
+    }
+    revokeModeratorInvite(username) {
+        return User.removeRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'moderator_invite',
+        });
+    }
+    removeModerator(username) {
+        return User.removeRelationship({
+            type: 'moderator',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            username,
+        });
+    }
+    setModeratorPermissions(username, permissions) {
+        return User.setModeratorPermissions(username, __classPrivateFieldGet(this, _Subreddit_name, "f"), permissions);
+    }
+    getMutedUsers(options = {}) {
+        return User.getSubredditUsersByType({
+            type: 'muted',
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    muteUser(username, note) {
+        return User.createRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'muted',
+            note,
+        });
+    }
+    unmuteUser(username) {
+        return User.removeRelationship({
+            username,
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            type: 'muted',
+        });
+    }
+    getModerationLog(options) {
+        return getModerationLog({
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    getUserFlairTemplates() {
+        return FlairTemplate.getUserFlairTemplates(__classPrivateFieldGet(this, _Subreddit_name, "f"));
+    }
+    getPostFlairTemplates() {
+        return FlairTemplate.getPostFlairTemplates(__classPrivateFieldGet(this, _Subreddit_name, "f"));
+    }
+    createPostFlairTemplate(options) {
+        return FlairTemplate.createPostFlairTemplate({
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    createUserFlairTemplate(options) {
+        return FlairTemplate.createUserFlairTemplate({
+            subredditName: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            ...options,
+        });
+    }
+    /**
+     * Get the user flair for the given subreddit. If `usernames` is provided then it will return only the
+     * flair for the specified users. If retrieving the list of flair for a given subreddit and the list is long
+     * then this method will return a `next` field which can be passed into the `after` field on the next call to
+     * retrieve the next slice of data. To retrieve the previous slice of data pass the `prev` field into the `before` field
+     * during the subsequent call.
+     *
+     * @param options See interface
+     *
+     * @example
+     * ```ts
+     * const subredditName = "mysubreddit"
+     * const subreddit = await reddit.getSubredditByName(subredditName)
+     * const response = await subreddit.getUserFlair();
+     * const userFlairList = response.users
+     * ```
+     * @example
+     * ```ts
+     * const response = await subreddit.getUserFlair({ after: "t2_awefae"});
+     * const userFlairList = response.users
+     * ```
+     *
+     * @example
+     * ```ts
+     * const response = await subreddit.getUserFlair({ usernames: ['toxictoad', 'badapple']});
+     * const userFlairList = response.users
+     * ```
+     */
+    async getUserFlair(options) {
+        if (options?.usernames !== undefined) {
+            const users = await Promise.all(options.usernames.map(async (name) => {
+                const response = await Flair.getUserFlairBySubreddit({
+                    subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+                    name,
+                });
+                return convertUserFlairProtoToAPI(response.users[0]);
+            }));
+            return { users };
+        }
+        else {
+            const response = await Flair.getUserFlairBySubreddit({
+                ...options,
+                subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+            });
+            return {
+                next: response.next,
+                prev: response.prev,
+                users: response.users.map((userFlair) => convertUserFlairProtoToAPI(userFlair)),
+            };
+        }
+    }
+    getModQueue(options = { type: 'all' }) {
+        return _a.aboutLocation({
+            ...options,
+            location: AboutLocations.Modqueue,
+            subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    getReports(options = { type: 'all' }) {
+        return _a.aboutLocation({
+            ...options,
+            location: AboutLocations.Reports,
+            subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    getSpam(options = { type: 'all' }) {
+        return _a.aboutLocation({
+            ...options,
+            location: AboutLocations.Spam,
+            subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    getUnmoderated(options = { type: 'all' }) {
+        return _a.aboutLocation({
+            ...options,
+            location: AboutLocations.Unmoderated,
+            subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    getEdited(options = { type: 'all' }) {
+        return _a.aboutLocation({
+            ...options,
+            location: AboutLocations.Edited,
+            subreddit: __classPrivateFieldGet(this, _Subreddit_name, "f"),
+        });
+    }
+    /** @internal */
+    static aboutLocation(options) {
+        const client = getRedditApiPlugins().Moderation;
+        let only;
+        switch (options.type) {
+            case 'post':
+                only = 'links';
+                break;
+            case 'comment':
+                only = 'comments';
+                break;
+            default:
+                only = undefined;
+        }
+        return new Listing({
+            ...options,
+            fetch: async (fetchOptions) => {
+                const listing = await client.AboutLocation({
+                    ...fetchOptions,
+                    ...options,
+                    only,
+                }, __classPrivateFieldGet(this, _a, "a", _Subreddit_metadata_get));
+                return parseListing(listing);
+            },
+        });
+    }
+    /**
+     * Return a listing of things specified by their fullnames.
+     *
+     * @param ids Array of thing full ids (e.g. t3_abc123)
+     * @example
+     * ```ts
+     * const subreddit = await reddit.getSubredditByName('askReddit');
+     * const listing = subreddit.getCommentsAndPostsByIds(['t3_abc123', 't1_xyz123']);
+     * const items = await listing.all();
+     * console.log(items) // [Post, Comment]
+     * ```
+     */
+    getCommentsAndPostsByIds(ids) {
+        const client = getRedditApiPlugins().LinksAndComments;
+        return new Listing({
+            fetch: async () => {
+                const listing = await client.Info({ thingIds: ids, subreddits: [__classPrivateFieldGet(this, _Subreddit_id, "f")] }, getContext().debug.metadata);
+                return parseListing(listing);
+            },
+        });
+    }
+    /** @internal */
+    static async addRemovalReason(subredditName, title, message) {
+        const client = getRedditApiPlugins().Subreddits;
+        const response = await client.SubredditAddRemovalReason({
+            title,
+            message,
+            subreddit: subredditName,
+        }, __classPrivateFieldGet(this, _a, "a", _Subreddit_metadata_get));
+        return response.id;
+    }
+    /** @internal */
+    static async getRemovalReasons(subredditName) {
+        const client = getRedditApiPlugins().Subreddits;
+        const result = await client.SubredditGetRemovalReasons({
+            subreddit: subredditName,
+        }, __classPrivateFieldGet(this, _a, "a", _Subreddit_metadata_get));
+        return result.order.map((id) => ({ ...result.data[id] }));
+    }
+    /** @internal */
+    static async getFromMetadata() {
+        const subredditName = getContext().subredditName;
+        if (subredditName) {
+            return _a.getByName(subredditName);
+        }
+        const subredditId = getContext().subredditId;
+        assertNonNull(subredditId);
+        return _a.getById(asT5ID(subredditId));
+    }
+    /** @internal */
+    static async getById(id) {
+        const subredditName = await getSubredditNameById(id);
+        if (!subredditName) {
+            return;
+        }
+        return _a.getByName(subredditName);
+    }
+    /** @internal */
+    static async getByName(subredditName) {
+        const client = getRedditApiPlugins().Subreddits;
+        const response = await client.SubredditAbout({
+            subreddit: subredditName,
+        }, __classPrivateFieldGet(this, _a, "a", _Subreddit_metadata_get));
+        if (!response?.data) {
+            throw new Error('not found');
+        }
+        return new _a(response.data);
+    }
+}
+_a = Subreddit, _Subreddit_id = new WeakMap(), _Subreddit_name = new WeakMap(), _Subreddit_createdAt = new WeakMap(), _Subreddit_type = new WeakMap(), _Subreddit_title = new WeakMap(), _Subreddit_description = new WeakMap(), _Subreddit_language = new WeakMap(), _Subreddit_numberOfSubscribers = new WeakMap(), _Subreddit_numberOfActiveUsers = new WeakMap(), _Subreddit_nsfw = new WeakMap(), _Subreddit_settings = new WeakMap(), _Subreddit_permalink = new WeakMap(), _Subreddit_metadata_get = function _Subreddit_metadata_get() {
+    return getContext().debug.metadata;
+};
+/**
+ * Gets a {@link SubredditInfo} object by ID
+ *
+ * @param {string} subredditId - The ID (starting with t5_) of the subreddit to retrieve. e.g. t5_2qjpg
+ * @returns {Promise<SubredditInfo>} A Promise that resolves a SubredditInfo object.
+ */
+export async function getSubredditInfoById(subredditId) {
+    const operationName = 'GetSubredditInfoById';
+    const persistedQueryHash = '315a9b75c22a017d526afdf2d274616946156451aacfd56dfb91e7ad3f7a2fde';
+    const response = await GraphQL.query(operationName, persistedQueryHash, { id: subredditId });
+    const subredditInfo = response.data?.subredditInfoById;
+    if (!subredditInfo)
+        throw new Error('subreddit info not found');
+    return subredditInfo;
+}
+/**
+ * Gets a {@link SubredditInfo} object by name
+ *
+ * @param {string} subredditName The name of a subreddit omitting the r/. This is case-insensitive.
+ * @returns {Promise<SubredditInfo>} A Promise that resolves a SubredditInfo object.
+ */
+export async function getSubredditInfoByName(subredditName) {
+    const operationName = 'GetSubredditInfoByName';
+    const persistedQueryHash = '4aa69726c7e3f5d33ab2bee22b3d74fce645824fddd5ea3ec6dfe30bdb4295cb';
+    const response = await GraphQL.query(operationName, persistedQueryHash, { name: subredditName });
+    const subredditInfo = response.data?.subredditInfoByName;
+    if (!subredditInfo)
+        throw new Error('subreddit info not found');
+    return subredditInfo;
+}
+export async function getSubredditLeaderboard(subredditId) {
+    const operationName = 'GetSubredditLeaderboard';
+    const persistedQueryHash = '18ead70c46b6446d45ecd8b679b16d9a929a933d6ef25d8262a459cb18b72848';
+    const response = await GraphQL.query(operationName, persistedQueryHash, { id: subredditId });
+    const leaderboard = response.data?.subredditInfoById?.leaderboard;
+    if (!leaderboard)
+        throw new Error('subreddit leaderboard not found');
+    if (!leaderboard.summary)
+        throw new Error('subreddit leaderboard summary not found');
+    return {
+        id: leaderboard.id,
+        summary: leaderboard.summary,
+    };
+}
+export async function getSubredditStyles(subredditId) {
+    const operationName = 'GetSubredditStyles';
+    const persistedQueryHash = 'd491d17ea8858f563ea578b26b9595d64adecf4bf34557d567c7e53c470f5f22';
+    const response = await GraphQL.query(operationName, persistedQueryHash, { id: subredditId });
+    const styles = response.data?.subredditInfoById?.styles;
+    if (!styles)
+        throw new Error('subreddit styles not found');
+    return styles;
+}
+function asSubredditType(type) {
+    if (type === 'public' ||
+        type === 'private' ||
+        type === 'restricted' ||
+        type === 'employees_only' ||
+        type === 'gold_only' ||
+        type === 'gold_restricted' ||
+        type === 'archived' ||
+        type === 'user') {
+        return type;
+    }
+    throw new Error(`invalid subreddit type: ${type}`);
+}
+function asAllowedPostType(type) {
+    if (type === 'any' || type === 'link' || type === 'self') {
+        return type;
+    }
+    throw new Error(`invalid allowed post type: ${type}`);
+}
+function asCommentMediaTypes(type) {
+    if (type === 'animated' || type === 'giphy' || type === 'static' || type === 'expression') {
+        return type;
+    }
+    throw new Error(`invalid comment media type: ${type}`);
+}
+function parseListing(listing) {
+    const children = listing.data?.children ?? [];
+    const postsAndComments = children
+        .map((child) => {
+        const post = tryParseAsPost(child);
+        if (post != null) {
+            return post;
+        }
+        const comment = tryParseAsComment(child);
+        if (comment != null) {
+            return comment;
+        }
+        return null;
+    })
+        .filter(Boolean);
+    return {
+        after: listing.data?.after,
+        before: listing.data?.before,
+        children: postsAndComments,
+    };
+    function tryParseAsPost(obj) {
+        try {
+            return new Post(obj.data);
+        }
+        catch {
+            return null;
+        }
+    }
+    function tryParseAsComment(obj) {
+        try {
+            return new Comment(obj.data);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** @internal */
+export async function getSubredditNameById(id) {
+    const client = getRedditApiPlugins().LinksAndComments;
+    const response = await client.Info({ thingIds: [id], subreddits: [] }, getContext().debug.metadata);
+    return response.data?.children[0]?.data?.displayName;
+}