@notidotbot/noti-api-client 1.9.86 → 1.9.88

package/dist/classes/feedback.d.ts

@@ -0,0 +1,552 @@
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+/**
+ * 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.
+ */
+export declare class APIFeedback {
+    private web;
+    constructor(web: WebDataManager);
+    /** Boards the viewer may see, with visible-post counts per status. */
+    getFeedbackBoards({ auth }?: FeedbackFunctionsInput['getFeedbackBoards']): Promise<import("../types").WebResponse<{
+        boards: FeedbackBoard[];
+    }>>;
+    getFeedbackTags({ auth }?: FeedbackFunctionsInput['getFeedbackTags']): Promise<import("../types").WebResponse<{
+        tags: FeedbackTag[];
+    }>>;
+    /**
+     * 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.
+     */
+    getFeedbackPosts({ auth, ...query }?: FeedbackFunctionsInput['getFeedbackPosts']): Promise<import("../types").WebResponse<FeedbackPostList>>;
+    /** Up to 5 visible posts whose titles look like `q` - the "is this already asked?" hint while typing a title. */
+    getSimilarFeedbackPosts({ auth, q }: FeedbackFunctionsInput['getSimilarFeedbackPosts']): Promise<import("../types").WebResponse<{
+        posts: FeedbackSimilarPost[];
+    }>>;
+    /**
+     * One post. A merged post answers `{ post: null, viewer: null, mergedInto }`: send the user to
+     * `mergedInto` (its old number keeps working this way).
+     */
+    getFeedbackPost({ auth, number }: FeedbackFunctionsInput['getFeedbackPost']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    /** Post an idea / request. The author votes and follows it automatically. 5 per hour. `uploadIds` from createFeedbackUpload. */
+    createFeedbackPost({ auth, post }: FeedbackFunctionsInput['createFeedbackPost']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    /** Edit your own post. Only while it is open / under review and has 10 or fewer votes (`viewer.canEdit`). */
+    updateFeedbackPost({ auth, number, post }: FeedbackFunctionsInput['updateFeedbackPost']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    /** Delete your own post - only while nobody else has voted on it (`ask_staff` otherwise). */
+    deleteFeedbackPost({ auth, number }: FeedbackFunctionsInput['deleteFeedbackPost']): Promise<import("../types").WebResponse<{
+        deleted: true;
+    }>>;
+    /** Vote. Voting also follows the post, unless the user unfollowed it before. 30 per minute. */
+    createFeedbackVote({ auth, number }: FeedbackFunctionsInput['createFeedbackVote']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    deleteFeedbackVote({ auth, number }: FeedbackFunctionsInput['deleteFeedbackVote']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    /** Follow: get notified when it changes status, ships, or gets an official answer. */
+    createFeedbackFollow({ auth, number }: FeedbackFunctionsInput['createFeedbackFollow']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    /** Unfollow. Sticks: voting again later does not re-follow. */
+    deleteFeedbackFollow({ auth, number }: FeedbackFunctionsInput['deleteFeedbackFollow']): Promise<import("../types").WebResponse<FeedbackPostView>>;
+    /**
+     * 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.
+     */
+    getFeedbackComments({ auth, number }: FeedbackFunctionsInput['getFeedbackComments']): Promise<import("../types").WebResponse<FeedbackThread>>;
+    /** Comment, or reply with `parentId` (a top-level comment only). `uploadIds` from createFeedbackUpload. 10/minute. Returns the thread. */
+    createFeedbackComment({ auth, number, comment }: FeedbackFunctionsInput['createFeedbackComment']): Promise<import("../types").WebResponse<FeedbackThread>>;
+    /** Edit your own comment. Returns the thread. */
+    updateFeedbackComment({ auth, commentId, body }: FeedbackFunctionsInput['updateFeedbackComment']): Promise<import("../types").WebResponse<FeedbackThread>>;
+    /** Delete your own comment (its replies stay). Returns the thread. */
+    deleteFeedbackComment({ auth, commentId }: FeedbackFunctionsInput['deleteFeedbackComment']): Promise<import("../types").WebResponse<FeedbackThread>>;
+    /** React to a post. Answers the post's reactions. `reactions_off` (404) when the switch is off. */
+    createFeedbackPostReaction({ auth, number, kind }: FeedbackFunctionsInput['createFeedbackPostReaction']): Promise<import("../types").WebResponse<{
+        reactions: FeedbackReactions;
+    }>>;
+    deleteFeedbackPostReaction({ auth, number, kind }: FeedbackFunctionsInput['deleteFeedbackPostReaction']): Promise<import("../types").WebResponse<{
+        reactions: FeedbackReactions;
+    }>>;
+    createFeedbackCommentReaction({ auth, commentId, kind }: FeedbackFunctionsInput['createFeedbackCommentReaction']): Promise<import("../types").WebResponse<{
+        reactions: FeedbackReactions;
+    }>>;
+    deleteFeedbackCommentReaction({ auth, commentId, kind }: FeedbackFunctionsInput['deleteFeedbackCommentReaction']): Promise<import("../types").WebResponse<{
+        reactions: FeedbackReactions;
+    }>>;
+    /**
+     * 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`.
+     */
+    createFeedbackUpload({ auth, formData }: FeedbackFunctionsInput['createFeedbackUpload']): Promise<import("../types").WebResponse<FeedbackUpload>>;
+    /** The roadmap: planned, in progress, and shipped in the last 30 days (older ones are on the timeline). */
+    getFeedbackRoadmap({ auth }?: FeedbackFunctionsInput['getFeedbackRoadmap']): Promise<import("../types").WebResponse<FeedbackRoadmap>>;
+    /** Shipped posts, newest first, each with the public changelog entry it shipped in (if staff linked one). */
+    getFeedbackTimeline({ auth, ...query }?: FeedbackFunctionsInput['getFeedbackTimeline']): Promise<import("../types").WebResponse<FeedbackTimeline>>;
+    /** Posts staff featured for the top of the feedback page (up to 10, in their order). */
+    getFeedbackFeatured({ auth }?: FeedbackFunctionsInput['getFeedbackFeatured']): Promise<import("../types").WebResponse<{
+        posts: FeedbackPostList["posts"];
+    }>>;
+    /**
+     * 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`.
+     */
+    getFeedbackNotifications({ auth, ...query }: FeedbackFunctionsInput['getFeedbackNotifications']): Promise<import("../types").WebResponse<FeedbackNotificationList>>;
+    /** The bell's number. Counts up to 100 (`capped` then true - show "99+"). */
+    getFeedbackNotificationCount({ auth }: FeedbackFunctionsInput['getFeedbackNotificationCount']): Promise<import("../types").WebResponse<{
+        unread: number;
+        capped: boolean;
+    }>>;
+    /** Mark notifications read: the given `ids`, or all of them when omitted. */
+    createFeedbackNotificationReads({ auth, ids }: FeedbackFunctionsInput['createFeedbackNotificationReads']): Promise<import("../types").WebResponse<{
+        read: number;
+    }>>;
+    /** DM settings. `dmBlocked`: Discord refused a DM (closed DMs) - switching DMs on again clears it. `dmsAvailable` false = DMs are off for everyone. */
+    getFeedbackSettings({ auth }: FeedbackFunctionsInput['getFeedbackSettings']): Promise<import("../types").WebResponse<FeedbackSettings>>;
+    /** Turn the update digest DM on or off (off by default; at most one DM per 15 minutes, 10 a day). */
+    updateFeedbackSettings({ auth, dmEnabled }: FeedbackFunctionsInput['updateFeedbackSettings']): Promise<import("../types").WebResponse<FeedbackSettings>>;
+    /** The "my feedback" page: my posts, what I voted on, what I follow (100 each, newest first). */
+    getMyFeedback({ auth }: FeedbackFunctionsInput['getMyFeedback']): Promise<import("../types").WebResponse<{
+        posts: FeedbackPost[];
+        voted: FeedbackPost[];
+        following: FeedbackPost[];
+    }>>;
+}
+export type FeedbackFunctionsInput = {
+    'getFeedbackBoards': {
+        auth?: string;
+    };
+    'getFeedbackTags': {
+        auth?: string;
+    };
+    'getFeedbackPosts': {
+        auth?: string;
+        board?: string;
+        tag?: string;
+        status?: FeedbackStatus;
+        q?: string;
+        sort?: FeedbackSort;
+        offset?: number;
+        limit?: number;
+    };
+    'getSimilarFeedbackPosts': {
+        auth?: string;
+        q: string;
+    };
+    'getFeedbackPost': {
+        auth?: string;
+        number: number;
+    };
+    'createFeedbackPost': {
+        auth: string;
+        post: {
+            boardId: string;
+            title: string;
+            body?: string;
+            tagIds?: string[];
+            uploadIds?: string[];
+        };
+    };
+    'updateFeedbackPost': {
+        auth: string;
+        number: number;
+        post: {
+            title?: string;
+            body?: string;
+            tagIds?: string[];
+            uploadIds?: string[];
+        };
+    };
+    'deleteFeedbackPost': {
+        auth: string;
+        number: number;
+    };
+    'createFeedbackVote': {
+        auth: string;
+        number: number;
+    };
+    'deleteFeedbackVote': {
+        auth: string;
+        number: number;
+    };
+    'createFeedbackFollow': {
+        auth: string;
+        number: number;
+    };
+    'deleteFeedbackFollow': {
+        auth: string;
+        number: number;
+    };
+    'getMyFeedback': {
+        auth: string;
+    };
+    'getFeedbackNotifications': {
+        auth: string;
+        before?: string;
+        limit?: number;
+    };
+    'getFeedbackNotificationCount': {
+        auth: string;
+    };
+    'createFeedbackNotificationReads': {
+        auth: string;
+        ids?: string[];
+    };
+    'getFeedbackSettings': {
+        auth: string;
+    };
+    'updateFeedbackSettings': {
+        auth: string;
+        dmEnabled: boolean;
+    };
+    'getFeedbackRoadmap': {
+        auth?: string;
+    };
+    'getFeedbackTimeline': {
+        auth?: string;
+        offset?: number;
+        limit?: number;
+    };
+    'getFeedbackFeatured': {
+        auth?: string;
+    };
+    'getFeedbackComments': {
+        auth?: string;
+        number: number;
+    };
+    'createFeedbackComment': {
+        auth: string;
+        number: number;
+        comment: {
+            body: string;
+            parentId?: string;
+            uploadIds?: string[];
+        };
+    };
+    'updateFeedbackComment': {
+        auth: string;
+        commentId: string;
+        body: string;
+    };
+    'deleteFeedbackComment': {
+        auth: string;
+        commentId: string;
+    };
+    'createFeedbackPostReaction': {
+        auth: string;
+        number: number;
+        kind: FeedbackReactionKind;
+    };
+    'deleteFeedbackPostReaction': {
+        auth: string;
+        number: number;
+        kind: FeedbackReactionKind;
+    };
+    'createFeedbackCommentReaction': {
+        auth: string;
+        commentId: string;
+        kind: FeedbackReactionKind;
+    };
+    'deleteFeedbackCommentReaction': {
+        auth: string;
+        commentId: string;
+        kind: FeedbackReactionKind;
+    };
+    /** FormData with one file under `image`. */
+    'createFeedbackUpload': {
+        auth: string;
+        formData: FormData;
+    };
+};
+export type FeedbackGetReturnTypes = {
+    'getFeedbackBoardsRaw': Awaited<ReturnType<APIFeedback['getFeedbackBoards']>>;
+    'getFeedbackBoardsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackBoards']>>>;
+    'getFeedbackTagsRaw': Awaited<ReturnType<APIFeedback['getFeedbackTags']>>;
+    'getFeedbackTagsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackTags']>>>;
+    'getFeedbackPostsRaw': Awaited<ReturnType<APIFeedback['getFeedbackPosts']>>;
+    'getFeedbackPostsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackPosts']>>>;
+    'getSimilarFeedbackPostsRaw': Awaited<ReturnType<APIFeedback['getSimilarFeedbackPosts']>>;
+    'getSimilarFeedbackPostsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getSimilarFeedbackPosts']>>>;
+    'getFeedbackPostRaw': Awaited<ReturnType<APIFeedback['getFeedbackPost']>>;
+    'getFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackPost']>>>;
+    'createFeedbackPostRaw': Awaited<ReturnType<APIFeedback['createFeedbackPost']>>;
+    'createFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackPost']>>>;
+    'updateFeedbackPostRaw': Awaited<ReturnType<APIFeedback['updateFeedbackPost']>>;
+    'updateFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['updateFeedbackPost']>>>;
+    'deleteFeedbackPostRaw': Awaited<ReturnType<APIFeedback['deleteFeedbackPost']>>;
+    'deleteFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['deleteFeedbackPost']>>>;
+    'createFeedbackVoteRaw': Awaited<ReturnType<APIFeedback['createFeedbackVote']>>;
+    'createFeedbackVoteSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackVote']>>>;
+    'deleteFeedbackVoteRaw': Awaited<ReturnType<APIFeedback['deleteFeedbackVote']>>;
+    'deleteFeedbackVoteSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['deleteFeedbackVote']>>>;
+    'createFeedbackFollowRaw': Awaited<ReturnType<APIFeedback['createFeedbackFollow']>>;
+    'createFeedbackFollowSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackFollow']>>>;
+    'deleteFeedbackFollowRaw': Awaited<ReturnType<APIFeedback['deleteFeedbackFollow']>>;
+    'deleteFeedbackFollowSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['deleteFeedbackFollow']>>>;
+    'getMyFeedbackRaw': Awaited<ReturnType<APIFeedback['getMyFeedback']>>;
+    'getMyFeedbackSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getMyFeedback']>>>;
+    'getFeedbackNotificationsRaw': Awaited<ReturnType<APIFeedback['getFeedbackNotifications']>>;
+    'getFeedbackNotificationsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackNotifications']>>>;
+    'getFeedbackNotificationCountRaw': Awaited<ReturnType<APIFeedback['getFeedbackNotificationCount']>>;
+    'getFeedbackNotificationCountSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackNotificationCount']>>>;
+    'createFeedbackNotificationReadsRaw': Awaited<ReturnType<APIFeedback['createFeedbackNotificationReads']>>;
+    'createFeedbackNotificationReadsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackNotificationReads']>>>;
+    'getFeedbackSettingsRaw': Awaited<ReturnType<APIFeedback['getFeedbackSettings']>>;
+    'getFeedbackSettingsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackSettings']>>>;
+    'updateFeedbackSettingsRaw': Awaited<ReturnType<APIFeedback['updateFeedbackSettings']>>;
+    'updateFeedbackSettingsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['updateFeedbackSettings']>>>;
+    'getFeedbackRoadmapRaw': Awaited<ReturnType<APIFeedback['getFeedbackRoadmap']>>;
+    'getFeedbackRoadmapSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackRoadmap']>>>;
+    'getFeedbackTimelineRaw': Awaited<ReturnType<APIFeedback['getFeedbackTimeline']>>;
+    'getFeedbackTimelineSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackTimeline']>>>;
+    'getFeedbackFeaturedRaw': Awaited<ReturnType<APIFeedback['getFeedbackFeatured']>>;
+    'getFeedbackFeaturedSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackFeatured']>>>;
+    'getFeedbackCommentsRaw': Awaited<ReturnType<APIFeedback['getFeedbackComments']>>;
+    'getFeedbackCommentsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['getFeedbackComments']>>>;
+    'createFeedbackCommentRaw': Awaited<ReturnType<APIFeedback['createFeedbackComment']>>;
+    'createFeedbackCommentSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackComment']>>>;
+    'updateFeedbackCommentRaw': Awaited<ReturnType<APIFeedback['updateFeedbackComment']>>;
+    'updateFeedbackCommentSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['updateFeedbackComment']>>>;
+    'deleteFeedbackCommentRaw': Awaited<ReturnType<APIFeedback['deleteFeedbackComment']>>;
+    'deleteFeedbackCommentSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['deleteFeedbackComment']>>>;
+    'createFeedbackPostReactionRaw': Awaited<ReturnType<APIFeedback['createFeedbackPostReaction']>>;
+    'createFeedbackPostReactionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackPostReaction']>>>;
+    'deleteFeedbackPostReactionRaw': Awaited<ReturnType<APIFeedback['deleteFeedbackPostReaction']>>;
+    'deleteFeedbackPostReactionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['deleteFeedbackPostReaction']>>>;
+    'createFeedbackCommentReactionRaw': Awaited<ReturnType<APIFeedback['createFeedbackCommentReaction']>>;
+    'createFeedbackCommentReactionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackCommentReaction']>>>;
+    'deleteFeedbackCommentReactionRaw': Awaited<ReturnType<APIFeedback['deleteFeedbackCommentReaction']>>;
+    'deleteFeedbackCommentReactionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['deleteFeedbackCommentReaction']>>>;
+    'createFeedbackUploadRaw': Awaited<ReturnType<APIFeedback['createFeedbackUpload']>>;
+    'createFeedbackUploadSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFeedback['createFeedbackUpload']>>>;
+};
+/** Mirrors `FeedbackAudienceEnum` in Noti-v3. A post's audience is the narrower of its board's and its own. */
+export declare const FEEDBACK_AUDIENCES: readonly ["public", "premium", "beta", "staff", "authorAndStaff"];
+export type FeedbackAudience = typeof FEEDBACK_AUDIENCES[number];
+/** Mirrors `FeedbackStatusEnum`. The roadmap columns are planned / inProgress / done. */
+export declare const FEEDBACK_STATUSES: readonly ["open", "underReview", "planned", "inProgress", "done", "declined"];
+export type FeedbackStatus = typeof FEEDBACK_STATUSES[number];
+export type FeedbackSort = 'top' | 'new' | 'trending';
+/** Why an action was refused. Mirrors `FEEDBACK_REFUSALS` in Noti-v3's `src/modules/feedback/visibility.ts`. */
+export declare const FEEDBACK_REFUSALS: readonly ["login_required", "not_visible", "banned", "account_too_new", "board_archived", "posting_closed", "voting_locked", "comments_locked"];
+export type FeedbackRefusal = typeof FEEDBACK_REFUSALS[number];
+/** Every `error.code` the member routes return. */
+export type FeedbackErrorCode = FeedbackRefusal | 'rate_limited' | 'busy' | 'title_too_short' | 'invalid_tag' | 'not_editable' | 'not_author' | 'ask_staff' | 'html_not_allowed' | 'foreign_image' | 'invalid_upload' | 'parent_not_found' | 'reply_depth' | 'invalid_reaction' | 'reactions_off' | 'uploads_off' | 'image_too_large' | 'unsupported_image' | 'invalid_image' | 'upload_quota' | 'no_image' | 'upload_failed';
+export type FeedbackBoard = {
+    boardId: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    audience: FeedbackAudience;
+    archived: boolean;
+    /** False when archived or closed to new posts (votes and comments may still be open). */
+    postingOpen: boolean;
+    position: number;
+    /** Visible posts per status, e.g. `{ open: 12, planned: 3 }`. */
+    counts: Partial<Record<FeedbackStatus, number>>;
+};
+export type FeedbackTag = {
+    tagId: string;
+    slug: string;
+    name: string; /** Hex, no #. */
+    color: string;
+};
+/** One post as the site shows it. Mirrors `FeedbackPostCard` in Noti-v3. */
+export type FeedbackPost = {
+    number: number;
+    board: {
+        boardId: string;
+        slug: string;
+        name: string;
+    } | null;
+    title: string;
+    /** Markdown - render with an allowlist. */
+    body: string;
+    status: FeedbackStatus;
+    /** Effective audience - show a badge ("Premium only") when not `public`. */
+    audience: FeedbackAudience;
+    /** Only on declined posts. */
+    declinedReason: string | null;
+    /** "2026-11" or "2026-Q4", only on planned / inProgress posts. */
+    eta: string | null;
+    tags: FeedbackTag[];
+    /** Includes `importedVotes`. */
+    voteCount: number;
+    /** Votes carried over from the old Fider board. */
+    importedVotes: number;
+    author: {
+        name: string;
+        isYou: boolean;
+        isStaff: boolean;
+    };
+    pinned: boolean;
+    featured: boolean;
+    /** True only for the author or staff - the post is hidden from everyone else. */
+    hidden: boolean;
+    /** Shown to the author when staff hid it. */
+    hiddenReason: string | null;
+    votingLocked: boolean;
+    commentsLocked: boolean;
+    mergedInto: number | null;
+    /** ISO. */
+    shippedAt: string | null;
+    editedAt: string | null;
+    createdAt: string;
+};
+export type FeedbackPostViewer = {
+    voted: boolean;
+    following: boolean;
+    canVote: boolean;
+    voteRefusal: FeedbackRefusal | null;
+    canComment: boolean;
+    commentRefusal: FeedbackRefusal | null;
+    canEdit: boolean;
+};
+export type FeedbackPostView = {
+    post: FeedbackPost & {
+        commentCount: number;
+        changelog: FeedbackChangelogLink | null;
+        polls: FeedbackPostPoll[];
+    };
+    viewer: FeedbackPostViewer;
+    reactions: FeedbackReactions;
+    mergedInto: null;
+} | {
+    post: null;
+    viewer: null;
+    reactions: null;
+    mergedInto: number;
+};
+export type FeedbackPostList = {
+    /** `commentCount` counts visible comments only (no staff notes, hidden or deleted). */
+    posts: Array<{
+        post: FeedbackPost & {
+            commentCount: number;
+        };
+        viewer: {
+            voted: boolean;
+            following: boolean;
+        };
+    }>;
+    total: number;
+    offset: number;
+    limit: number;
+};
+export type FeedbackSimilarPost = {
+    number: number;
+    title: string;
+    status: FeedbackStatus;
+    voteCount: number;
+};
+/** Mirrors `FEEDBACK_REACTION_KINDS` in Noti-v3. */
+export declare const FEEDBACK_REACTION_KINDS: readonly ["heart", "thumbsUp", "thumbsDown", "fire"];
+export type FeedbackReactionKind = typeof FEEDBACK_REACTION_KINDS[number];
+export type FeedbackReactions = {
+    counts: Record<FeedbackReactionKind, number>;
+    /** This viewer's own. */
+    mine: FeedbackReactionKind[];
+};
+export type FeedbackComment = {
+    commentId: string;
+    parentId: string | null;
+    /** Markdown; null when deleted. */
+    body: string | null;
+    deleted: boolean;
+    author: {
+        name: string;
+        isYou: boolean;
+        isStaff: boolean;
+    } | null;
+    /** A staff-only note - only staff ever receive these. */
+    internal: boolean;
+    official: boolean;
+    /** True only for the author or staff. */
+    hidden: boolean;
+    editedAt: string | null;
+    createdAt: string;
+    canEdit: boolean;
+    reactions: FeedbackReactions | null;
+};
+export type FeedbackThread = {
+    /** The pinned staff answer, shown first. */
+    official: FeedbackComment | null;
+    comments: Array<FeedbackComment & {
+        replies: FeedbackComment[];
+    }>;
+    total: number;
+};
+export type FeedbackUpload = {
+    uploadId: string;
+    url: string;
+    width: number;
+    height: number;
+};
+/** A public changelog entry a shipped post was linked to. `identifier` is the changelog's own id on the site. */
+export type FeedbackChangelogLink = {
+    identifier: string;
+    title: string;
+    date: string;
+};
+/** An open site poll this post is an option in - show "in a poll now" and link to the poll. */
+export type FeedbackPostPoll = {
+    pollId: string;
+    title: string;
+    closesAt: string | null;
+    optionId: string;
+};
+export type FeedbackRoadmap = {
+    planned: Array<FeedbackPost & {
+        commentCount: number;
+    }>;
+    inProgress: Array<FeedbackPost & {
+        commentCount: number;
+    }>;
+    /** Shipped in the last 30 days, newest first. */
+    done: Array<FeedbackPost & {
+        commentCount: number;
+    }>;
+};
+export type FeedbackTimeline = {
+    entries: Array<{
+        post: FeedbackPost;
+        changelog: FeedbackChangelogLink | null;
+    }>;
+    total: number;
+    offset: number;
+    limit: number;
+};
+/** Mirrors `FEEDBACK_NOTIFICATION_KINDS` in Noti-v3. `merged`: the post you followed was merged into `post`. */
+export declare const FEEDBACK_NOTIFICATION_KINDS: readonly ["statusChanged", "shipped", "officialAnswer", "reply", "merged", "pollStarted"];
+export type FeedbackNotificationKind = typeof FEEDBACK_NOTIFICATION_KINDS[number];
+export type FeedbackNotification = {
+    notificationId: string;
+    kind: FeedbackNotificationKind;
+    /** The reply or official answer, for `reply` / `officialAnswer`. */
+    commentId: string | null;
+    read: boolean;
+    createdAt: string;
+    /** As it is NOW (title and status are live, not a copy from when it happened). */
+    post: FeedbackPost;
+};
+export type FeedbackNotificationList = {
+    notifications: FeedbackNotification[];
+    next: string | null;
+};
+export type FeedbackSettings = {
+    dmEnabled: boolean;
+    dmBlocked: boolean;
+    dmsAvailable: boolean;
+};