@notidotbot/noti-api-client 1.9.85 → 1.9.87

package/dist/classes/feedback.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEEDBACK_NOTIFICATION_KINDS = exports.FEEDBACK_REACTION_KINDS = exports.FEEDBACK_REFUSALS = exports.FEEDBACK_STATUSES = exports.FEEDBACK_AUDIENCES = exports.APIFeedback = void 0;
+// Data.
+/**
+ * The feedback board - ideas and private requests, votes, follows (replaces Fider at feedback.noti.bot).
+ *
+ * ── WHO SEES WHAT ──────────────────────────────────────────────────────────
+ * Reads work logged out: pass `auth` ONLY when the user is logged in. With a session the server answers for
+ * that user (premium-only boards, their own hidden posts, staff view) and marks the response `private,
+ * no-store`; without one it answers the public view and lets it be cached. Never cache a logged-in response
+ * on the page side as if it were public.
+ *
+ * Behind the `feedback` launch flag: while it is hidden for the caller every method 404s. A post the viewer
+ * may not see is 404 too, never 403 - do not show "forbidden", show "not found".
+ *
+ * ── REFUSALS ───────────────────────────────────────────────────────────────
+ * A refused write is `{ status, error: { code } }`, `code` from `FeedbackErrorCode`. `voteRefusal` /
+ * `commentRefusal` on a post's `viewer` tell you up front why the buttons are off (banned, new account,
+ * archived board, locked post), so the page can say so instead of letting the click fail.
+ *
+ * ── TEXT ───────────────────────────────────────────────────────────────────
+ * `title` is plain text. `body` is MARKDOWN, stored raw: render it with an allowlist (no raw HTML, images
+ * only from Noti's own host, links `rel="nofollow ugc noopener"`). The server does not sanitise HTML for you.
+ */
+class APIFeedback {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    /** Boards the viewer may see, with visible-post counts per status. */
+    async getFeedbackBoards({ auth } = {}) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/boards'),
+        });
+    }
+    async getFeedbackTags({ auth } = {}) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/tags'),
+        });
+    }
+    /**
+     * The list. `board` / `tag` take a slug or id; `sort` is `top` (default, pinned first inside a board),
+     * `new` or `trending` (votes in the last 14 days). `limit` up to 50. Searching logged out is rate limited.
+     */
+    async getFeedbackPosts({ auth, ...query } = {}) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/posts', query),
+        });
+    }
+    /** Up to 5 visible posts whose titles look like `q` - the "is this already asked?" hint while typing a title. */
+    async getSimilarFeedbackPosts({ auth, q }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/posts/similar', { q }),
+        });
+    }
+    /**
+     * One post. A merged post answers `{ post: null, viewer: null, mergedInto }`: send the user to
+     * `mergedInto` (its old number keeps working this way).
+     */
+    async getFeedbackPost({ auth, number }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number),
+        });
+    }
+    /** Post an idea / request. The author votes and follows it automatically. 5 per hour. */
+    async createFeedbackPost({ auth, post }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/public/feedback/posts'),
+            body: post,
+        });
+    }
+    /** Edit your own post. Only while it is open / under review and has 10 or fewer votes (`viewer.canEdit`). */
+    async updateFeedbackPost({ auth, number, post }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number),
+            body: post,
+        });
+    }
+    /** Delete your own post - only while nobody else has voted on it (`ask_staff` otherwise). */
+    async deleteFeedbackPost({ auth, number }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number),
+        });
+    }
+    /** Vote. Voting also follows the post, unless the user unfollowed it before. 30 per minute. */
+    async createFeedbackVote({ auth, number }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/votes/@me'),
+        });
+    }
+    async deleteFeedbackVote({ auth, number }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/votes/@me'),
+        });
+    }
+    /** Follow: get notified when it changes status, ships, or gets an official answer. */
+    async createFeedbackFollow({ auth, number }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/follows/@me'),
+        });
+    }
+    /** Unfollow. Sticks: voting again later does not re-follow. */
+    async deleteFeedbackFollow({ auth, number }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/follows/@me'),
+        });
+    }
+    /**
+     * The thread: the official staff answer first, then comments oldest first with their replies (one level).
+     * Staff notes (`internal`) only reach staff. A deleted comment shows as `deleted: true` with no body while it
+     * still has replies.
+     */
+    async getFeedbackComments({ auth, number }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/comments'),
+        });
+    }
+    /** Comment, or reply with `parentId` (a top-level comment only). `uploadIds` from createFeedbackUpload. 10/minute. Returns the thread. */
+    async createFeedbackComment({ auth, number, comment }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/comments'),
+            body: comment,
+        });
+    }
+    /** Edit your own comment. Returns the thread. */
+    async updateFeedbackComment({ auth, commentId, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/public/feedback/comments/' + commentId),
+            body: { body },
+        });
+    }
+    /** Delete your own comment (its replies stay). Returns the thread. */
+    async deleteFeedbackComment({ auth, commentId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/public/feedback/comments/' + commentId),
+        });
+    }
+    /** React to a post. Answers the post's reactions. `reactions_off` (404) when the switch is off. */
+    async createFeedbackPostReaction({ auth, number, kind }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/reactions/' + kind),
+        });
+    }
+    async deleteFeedbackPostReaction({ auth, number, kind }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/public/feedback/posts/' + number + '/reactions/' + kind),
+        });
+    }
+    async createFeedbackCommentReaction({ auth, commentId, kind }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/public/feedback/comments/' + commentId + '/reactions/' + kind),
+        });
+    }
+    async deleteFeedbackCommentReaction({ auth, commentId, kind }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/public/feedback/comments/' + commentId + '/reactions/' + kind),
+        });
+    }
+    /**
+     * Upload one image (field `image`: png, jpeg, webp or gif, up to 8 MB). It comes back as webp, at most
+     * 2000px, with its metadata (GPS, camera) removed. Put `url` in the markdown as `![alt](url)` and send
+     * `uploadId` in `uploadIds` when saving the post or comment; unattached uploads are deleted after 24h.
+     * 20 per day. Refusals: `uploads_off`, `image_too_large`, `unsupported_image`, `invalid_image`, `upload_quota`.
+     */
+    async createFeedbackUpload({ auth, formData }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/public/feedback/uploads'),
+            body: formData,
+        });
+    }
+    /** The roadmap: planned, in progress, and shipped in the last 30 days (older ones are on the timeline). */
+    async getFeedbackRoadmap({ auth } = {}) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/roadmap'),
+        });
+    }
+    /** Shipped posts, newest first, each with the public changelog entry it shipped in (if staff linked one). */
+    async getFeedbackTimeline({ auth, ...query } = {}) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/timeline', query),
+        });
+    }
+    /** Posts staff featured for the top of the feedback page (up to 10, in their order). */
+    async getFeedbackFeatured({ auth } = {}) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/featured'),
+        });
+    }
+    /**
+     * The inbox (the bell): newest first. Visibility is checked when you read it, so a post that has gone
+     * private is simply not there. Page with `before` = the previous page's `next`.
+     */
+    async getFeedbackNotifications({ auth, ...query }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/users/@me/notifications', query),
+        });
+    }
+    /** The bell's number. Counts up to 100 (`capped` then true - show "99+"). */
+    async getFeedbackNotificationCount({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/users/@me/notifications/unread'),
+        });
+    }
+    /** Mark notifications read: the given `ids`, or all of them when omitted. */
+    async createFeedbackNotificationReads({ auth, ids }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/public/feedback/users/@me/notifications/reads'),
+            body: ids ? { ids } : {},
+        });
+    }
+    /** DM settings. `dmBlocked`: Discord refused a DM (closed DMs) - switching DMs on again clears it. `dmsAvailable` false = DMs are off for everyone. */
+    async getFeedbackSettings({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/users/@me/settings'),
+        });
+    }
+    /** Turn the update digest DM on or off (off by default; at most one DM per 15 minutes, 10 a day). */
+    async updateFeedbackSettings({ auth, dmEnabled }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/public/feedback/users/@me/settings'),
+            body: { dmEnabled },
+        });
+    }
+    /** The "my feedback" page: my posts, what I voted on, what I follow (100 each, newest first). */
+    async getMyFeedback({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/public/feedback/users/@me'),
+        });
+    }
+}
+exports.APIFeedback = APIFeedback;
+/** Mirrors `FeedbackAudienceEnum` in Noti-v3. A post's audience is the narrower of its board's and its own. */
+exports.FEEDBACK_AUDIENCES = ['public', 'premium', 'beta', 'staff', 'authorAndStaff'];
+/** Mirrors `FeedbackStatusEnum`. The roadmap columns are planned / inProgress / done. */
+exports.FEEDBACK_STATUSES = ['open', 'underReview', 'planned', 'inProgress', 'done', 'declined'];
+/** Why an action was refused. Mirrors `FEEDBACK_REFUSALS` in Noti-v3's `src/modules/feedback/visibility.ts`. */
+exports.FEEDBACK_REFUSALS = [
+    'login_required', 'not_visible', 'banned', 'account_too_new', 'board_archived', 'posting_closed', 'voting_locked', 'comments_locked',
+];
+/** Mirrors `FEEDBACK_REACTION_KINDS` in Noti-v3. */
+exports.FEEDBACK_REACTION_KINDS = ['heart', 'thumbsUp', 'thumbsDown', 'fire'];
+/** Mirrors `FEEDBACK_NOTIFICATION_KINDS` in Noti-v3. `merged`: the post you followed was merged into `post`. */
+exports.FEEDBACK_NOTIFICATION_KINDS = ['statusChanged', 'shipped', 'officialAnswer', 'reply', 'merged', 'pollStarted'];

package/dist/classes/guildEmojis.d.ts

@@ -0,0 +1,120 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses, WebResponse } from '../types';
+/**
+ * Reposition Emojis - reorder a server's emojis in Discord's emoji picker.
+ *
+ * Discord has no reorder API: the picker lists a server's emojis oldest upload first. So Noti re-uploads the emojis
+ * that have to move, in the new order, and deletes the originals. **Every re-uploaded emoji gets a new id**: Noti
+ * updates its own settings (role panels, starboards, message buttons, `<:name:id>` in message text) and re-renders
+ * posted role panels, but emojis in old chat messages and other bots' settings may show as broken.
+ *
+ * Only what must move is re-uploaded: emojis at the start of the new order that are already in age order keep their
+ * place. Integration emojis (`managed`) and greyed-out ones (`available: false`) can never move - pin them.
+ *
+ * Free servers: one reposition per 7 days (`nextFreeAt`). Premium: unlimited (`unlimited`). Starting one needs a top.gg
+ * vote (403 `vote_required`, Premium skips it) and Manage Expressions for both the caller and Noti. Behind the
+ * `repositionEmojis` launch flag: every method answers 403 `not_available` until it is beta/public for the caller.
+ */
+export declare class APIGuildEmojis {
+    private web;
+    constructor(web: WebDataManager);
+    /** The server's emojis in picker order, its slot limits, the weekly cap, permissions, and the current / last job. */
+    getGuildEmojis({ auth, guildId }: GuildEmojisFunctionsInput['getGuildEmojis']): Promise<WebResponse<GuildEmojisData>>;
+    /**
+     * Start a reposition. `order` is EVERY emoji id in the server, in the new order. Runs in the background - poll
+     * `getEmojiReposition` for progress (large servers can take hours: Discord limits emoji uploads).
+     *
+     * Errors (`error.code`): 400 `invalid_body` / `mismatch` (the list changed - reload) / `noop` / `managed_locked` /
+     * `unavailable_locked` (`error.ids`) / `over_limit`; 403 `not_available` / `vote_required` / `not_manager` /
+     * `missing_permissions`; 409 `running`; 429 `weekly_limit` (`error.resetsAt`, `error.premiumUrl`); 503
+     * `guild_unavailable`.
+     */
+    createEmojiReposition({ auth, guildId, order }: GuildEmojisFunctionsInput['createEmojiReposition']): Promise<WebResponse<{
+        job: EmojiRepositionJob;
+    }>>;
+    /** The current or last job (kept 7 days after it ends), or null. */
+    getEmojiReposition({ auth, guildId }: GuildEmojisFunctionsInput['getEmojiReposition']): Promise<WebResponse<{
+        job: EmojiRepositionJob | null;
+    }>>;
+}
+export type GuildEmoji = {
+    id: string;
+    name: string;
+    animated: boolean;
+    /** Integration (Twitch / YouTube) emoji: cannot be moved. */
+    managed: boolean;
+    /** False when greyed out (over the limit after a boost-level drop): cannot be moved. */
+    available: boolean;
+    /** Restricted to roles; the re-upload keeps the restriction. */
+    roleLocked: boolean;
+    url: string;
+};
+export type GuildEmojisData = {
+    /** Picker order: oldest upload first. */
+    emojis: GuildEmoji[];
+    /** Static and animated each have `max` slots. */
+    limits: {
+        static: number;
+        animated: number;
+        max: number;
+    };
+    canManage: {
+        bot: boolean;
+        member: boolean;
+    };
+    /** Premium: no weekly cap. */
+    unlimited: boolean;
+    /** Free servers: when the next reposition is allowed (ms), or null when one is free now. */
+    nextFreeAt: number | null;
+    job: EmojiRepositionJob | null;
+};
+/** One emoji's progress. `skipped` = someone deleted it during the job; `failed` carries `error`. */
+export type EmojiRepositionStep = 'pending' | 'backedUp' | 'creating' | 'created' | 'deleting' | 'done' | 'failed' | 'skipped';
+export type EmojiRepositionJob = {
+    jobId: string;
+    guildId: string;
+    startedBy: string;
+    startedAt: number;
+    status: 'backing-up' | 'moving' | 'repointing' | 'done' | 'failed';
+    /** Emojis that kept their place. */
+    keep: string[];
+    /** Emojis being re-uploaded, in order. `newId` once its copy exists. */
+    emojis: Array<{
+        id: string;
+        name: string;
+        animated: boolean;
+        roles: string[];
+        step: EmojiRepositionStep;
+        newId?: string;
+        deletedFirst?: boolean;
+        backupKey?: string;
+        error?: string;
+    }>;
+    movedAny: boolean;
+    /** Why it failed, e.g. `backup_too_large:<id>`, `emoji_down:<id>`, `repoint_failed`. */
+    failure?: string;
+    finishedAt?: number;
+};
+export type GuildEmojisFunctionsInput = {
+    'getGuildEmojis': {
+        auth: string;
+        guildId: string;
+    };
+    'createEmojiReposition': {
+        auth: string;
+        guildId: string;
+        order: string[];
+    };
+    'getEmojiReposition': {
+        auth: string;
+        guildId: string;
+    };
+};
+export type GuildEmojisReturnTypes = {
+    'getGuildEmojisRaw': Awaited<ReturnType<APIGuildEmojis['getGuildEmojis']>>;
+    'getGuildEmojisSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildEmojis['getGuildEmojis']>>>;
+    'createEmojiRepositionRaw': Awaited<ReturnType<APIGuildEmojis['createEmojiReposition']>>;
+    'createEmojiRepositionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildEmojis['createEmojiReposition']>>>;
+    'getEmojiRepositionRaw': Awaited<ReturnType<APIGuildEmojis['getEmojiReposition']>>;
+    'getEmojiRepositionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildEmojis['getEmojiReposition']>>>;
+};

package/dist/classes/guildEmojis.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildEmojis = void 0;
+/**
+ * Reposition Emojis - reorder a server's emojis in Discord's emoji picker.
+ *
+ * Discord has no reorder API: the picker lists a server's emojis oldest upload first. So Noti re-uploads the emojis
+ * that have to move, in the new order, and deletes the originals. **Every re-uploaded emoji gets a new id**: Noti
+ * updates its own settings (role panels, starboards, message buttons, `<:name:id>` in message text) and re-renders
+ * posted role panels, but emojis in old chat messages and other bots' settings may show as broken.
+ *
+ * Only what must move is re-uploaded: emojis at the start of the new order that are already in age order keep their
+ * place. Integration emojis (`managed`) and greyed-out ones (`available: false`) can never move - pin them.
+ *
+ * Free servers: one reposition per 7 days (`nextFreeAt`). Premium: unlimited (`unlimited`). Starting one needs a top.gg
+ * vote (403 `vote_required`, Premium skips it) and Manage Expressions for both the caller and Noti. Behind the
+ * `repositionEmojis` launch flag: every method answers 403 `not_available` until it is beta/public for the caller.
+ */
+class APIGuildEmojis {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    /** The server's emojis in picker order, its slot limits, the weekly cap, permissions, and the current / last job. */
+    async getGuildEmojis({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/emojis`),
+        });
+    }
+    /**
+     * Start a reposition. `order` is EVERY emoji id in the server, in the new order. Runs in the background - poll
+     * `getEmojiReposition` for progress (large servers can take hours: Discord limits emoji uploads).
+     *
+     * Errors (`error.code`): 400 `invalid_body` / `mismatch` (the list changed - reload) / `noop` / `managed_locked` /
+     * `unavailable_locked` (`error.ids`) / `over_limit`; 403 `not_available` / `vote_required` / `not_manager` /
+     * `missing_permissions`; 409 `running`; 429 `weekly_limit` (`error.resetsAt`, `error.premiumUrl`); 503
+     * `guild_unavailable`.
+     */
+    async createEmojiReposition({ auth, guildId, order }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/emojis/repositions`),
+            body: { order },
+        });
+    }
+    /** The current or last job (kept 7 days after it ends), or null. */
+    async getEmojiReposition({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/emojis/repositions/current`),
+        });
+    }
+}
+exports.APIGuildEmojis = APIGuildEmojis;

package/dist/classes/polls.d.ts

@@ -86,6 +86,8 @@ export type SitePollOption = {
     optionId: string;
     label: string;
     description: string | null;
+    /** The feedback post this option stands for - link to it. Null when none, or while that post is not public. */
+    postNumber: number | null;
 };
 export type SitePollResults = {
     /** In display order. */

package/dist/classes/socials.d.ts

@@ -0,0 +1,75 @@
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APISocials {
+    private web;
+    constructor(web: WebDataManager);
+    /** The user's linked accounts per platform, with the limit and whether YouTube is available to them yet. */
+    getSocials({ auth }: SocialsFunctionsInput['getSocials']): Promise<import("../types").WebResponse<SocialAccountsView>>;
+    /**
+     * Link an X or Club account by its handle (`@name`, a profile link, or the bare name). Typed links are unverified.
+     * Errors: 400 invalid handle, 404 no such account, 409 limit / taken / locked, 403 banned or not available, 429 too
+     * fast, 503 the platform could not be reached (try again - it is not "not found").
+     */
+    createSocial({ auth, platform, username }: SocialsFunctionsInput['createSocial']): Promise<import("../types").WebResponse<{
+        account: {
+            dbId: string;
+            created: boolean;
+        };
+        view: SocialAccountsView | null;
+    }>>;
+    /** Make an account the platform's primary. 409 while the platform is locked (User Premium ended with extras). */
+    updateSocial({ auth, accountId }: SocialsFunctionsInput['updateSocial']): Promise<import("../types").WebResponse<SocialAccountsView | null>>;
+    /** Unlink an account. Always allowed. Unlinking the primary makes the oldest remaining one primary. */
+    deleteSocial({ auth, accountId }: SocialsFunctionsInput['deleteSocial']): Promise<import("../types").WebResponse<SocialAccountsView | null>>;
+}
+export type SocialPlatform = 'youtube' | 'twitter' | 'club';
+export type UsernameSocialPlatform = 'twitter' | 'club';
+/** `ok` room left, `full` at the limit, `over` = User Premium ended with extra accounts: locked until unlinked down. */
+export type SocialAccountState = 'ok' | 'full' | 'over';
+export type SocialAccount = {
+    dbId: string;
+    username: string;
+    displayName: string | null;
+    /** true = proven by login (YouTube); false = typed handle (X, Club). */
+    verified: boolean;
+    isPrimary: boolean;
+};
+export type SocialAccountsView = {
+    /** Developers only for now (`latestYoutube`). Hide every YouTube control when false. */
+    canYoutube: boolean;
+    /** Accounts allowed per platform: 1 free, 3 with User Premium. */
+    limit: number;
+    platforms: {
+        platform: SocialPlatform;
+        state: SocialAccountState;
+        accounts: SocialAccount[];
+    }[];
+};
+export type SocialsFunctionsInput = {
+    'getSocials': {
+        auth: string;
+    };
+    'createSocial': {
+        auth: string;
+        platform: UsernameSocialPlatform;
+        username: string;
+    };
+    'updateSocial': {
+        auth: string;
+        accountId: string;
+    };
+    'deleteSocial': {
+        auth: string;
+        accountId: string;
+    };
+};
+export type SocialsGetReturnTypes = {
+    'getSocialsRaw': Awaited<ReturnType<APISocials['getSocials']>>;
+    'getSocialsSuccess': CancelOutWebResponses<Awaited<ReturnType<APISocials['getSocials']>>>;
+    'createSocialRaw': Awaited<ReturnType<APISocials['createSocial']>>;
+    'createSocialSuccess': CancelOutWebResponses<Awaited<ReturnType<APISocials['createSocial']>>>;
+    'updateSocialRaw': Awaited<ReturnType<APISocials['updateSocial']>>;
+    'updateSocialSuccess': CancelOutWebResponses<Awaited<ReturnType<APISocials['updateSocial']>>>;
+    'deleteSocialRaw': Awaited<ReturnType<APISocials['deleteSocial']>>;
+    'deleteSocialSuccess': CancelOutWebResponses<Awaited<ReturnType<APISocials['deleteSocial']>>>;
+};

package/dist/classes/socials.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APISocials = void 0;
+// Linked YouTube / X / Club accounts (Noti-v3 phases/latest/). Behind the `latest` launch flag - every route 403s while it
+// is hidden for the user. 1 account per platform free, 3 with User Premium (the `MultipleSocialAccounts` user bit); one
+// primary per platform, which /latest uses when no account is picked.
+class APISocials {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    /** The user's linked accounts per platform, with the limit and whether YouTube is available to them yet. */
+    async getSocials({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/@me/socials'),
+        });
+    }
+    /**
+     * Link an X or Club account by its handle (`@name`, a profile link, or the bare name). Typed links are unverified.
+     * Errors: 400 invalid handle, 404 no such account, 409 limit / taken / locked, 403 banned or not available, 429 too
+     * fast, 503 the platform could not be reached (try again - it is not "not found").
+     */
+    async createSocial({ auth, platform, username }) {
+        return await this.web.request({
+            method: 'POST', auth, body: { username },
+            endpoint: this.web.qp('/@me/socials/' + platform),
+        });
+    }
+    /** Make an account the platform's primary. 409 while the platform is locked (User Premium ended with extras). */
+    async updateSocial({ auth, accountId }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: { isPrimary: true },
+            endpoint: this.web.qp('/@me/socials/accounts/' + accountId),
+        });
+    }
+    /** Unlink an account. Always allowed. Unlinking the primary makes the oldest remaining one primary. */
+    async deleteSocial({ auth, accountId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/@me/socials/accounts/' + accountId),
+        });
+    }
+}
+exports.APISocials = APISocials;

package/dist/core/manager.d.ts

@@ -15,6 +15,7 @@ import { APIGuildBounties } from '../classes/guildBounties';
 import { APIGuildAssistant } from '../classes/guildAssistant';
 import { APIGuildAutoRoles } from '../classes/guildAutoRoles';
 import { APIGuildBoosts } from '../classes/guildBoosts';
+import { APIGuildEmojis } from '../classes/guildEmojis';
 import { APIGuildMembers } from '../classes/guildMembers';
 import { APIGuildHealth } from '../classes/guildHealth';
 import { APIGuildInfluencerPanel } from '../classes/guildInfluencerPanel';
@@ -40,12 +41,15 @@ import { APIPublicDrops } from '../classes/publicDrops';
 import { APIPolls } from '../classes/polls';
 import { APIAnnouncements } from '../classes/announcements';
 import { APIAdminPolls } from '../classes/adminPolls';
+import { APIFeedback } from '../classes/feedback';
+import { APIAdminFeedback } from '../classes/adminFeedback';
 import { APIAdminAnnouncements } from '../classes/adminAnnouncements';
 import { APIGuildFishing } from '../classes/guildFishing';
 import { APIAdminFishing } from '../classes/adminFishing';
 import { APIAdmin } from '../classes/admin';
 import { APIVods } from '../classes/vods';
 import { APIUser } from '../classes/user';
+import { APISocials } from '../classes/socials';
 import { APIMe } from '../classes/@me';
 export declare class WebDataManager {
     url: string;
@@ -54,6 +58,7 @@ export declare class WebDataManager {
     } | undefined;
     readonly me: APIMe;
     readonly user: APIUser;
+    readonly socials: APISocials;
     readonly emotes: APIEmotes;
     readonly vods: APIVods;
     readonly files: APIFiles;
@@ -68,6 +73,8 @@ export declare class WebDataManager {
     readonly announcements: APIAnnouncements;
     readonly adminPolls: APIAdminPolls;
     readonly adminAnnouncements: APIAdminAnnouncements;
+    readonly feedback: APIFeedback;
+    readonly adminFeedback: APIAdminFeedback;
     readonly other: APIOther;
     readonly guild: APIGuild;
     readonly teams: APITeams;
@@ -84,6 +91,7 @@ export declare class WebDataManager {
     readonly guildAssistant: APIGuildAssistant;
     readonly guildAutoRoles: APIGuildAutoRoles;
     readonly guildBoosts: APIGuildBoosts;
+    readonly guildEmojis: APIGuildEmojis;
     readonly guildMembers: APIGuildMembers;
     readonly guildHealth: APIGuildHealth;
     readonly guildInfluencerPanel: APIGuildInfluencerPanel;