@notidotbot/noti-api-client 1.9.86 → 1.9.88

package/dist/classes/adminFeedback.d.ts

@@ -0,0 +1,336 @@
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+import type { FeedbackAudience, FeedbackPost, FeedbackStatus, FeedbackThread } from './feedback';
+/**
+ * The feedback board - the staff side. Post moderation, tags and bans are staff + developers; boards (and
+ * rewriting a post's `title` / `body`) are developers only (403 otherwise). None is behind the `feedback`
+ * flag, so boards can be set up before launch. Every change is written to the audit log (`getFeedbackAudits`).
+ */
+export declare class APIAdminFeedback {
+    private web;
+    constructor(web: WebDataManager);
+    /** Every post incl. hidden / private. `deleted: true` lists deleted ones instead; `merged: true` includes merged ones. */
+    getAdminFeedbackPosts({ auth, ...query }: AdminFeedbackFunctionsInput['getAdminFeedbackPosts']): Promise<import("../types").WebResponse<{
+        posts: AdminFeedbackPost[];
+        total: number;
+        offset: number;
+        limit: number;
+    }>>;
+    /** One post with who wants it: votes by plan, voters' server reach, share from accounts under 30 days. */
+    getAdminFeedbackPost({ auth, number }: AdminFeedbackFunctionsInput['getAdminFeedbackPost']): Promise<import("../types").WebResponse<{
+        post: AdminFeedbackPost;
+        breakdown: FeedbackVoteBreakdown;
+    }>>;
+    /**
+     * Moderate a post; send only what changes. `status: 'done'` sets `shippedAt`. `audienceOverride` may only
+     * narrow the board (`audience_widens_board`). `featured` puts it on the main page (until `featuredUntil`).
+     * `deleted` soft-deletes / restores. `title` / `body` are developers only.
+     */
+    updateAdminFeedbackPost({ auth, number, post }: AdminFeedbackFunctionsInput['updateAdminFeedbackPost']): Promise<import("../types").WebResponse<{
+        post: AdminFeedbackPost | null;
+    }>>;
+    deleteAdminFeedbackPost({ auth, number }: AdminFeedbackFunctionsInput['deleteAdminFeedbackPost']): Promise<import("../types").WebResponse<{
+        post: AdminFeedbackPost | null;
+    }>>;
+    /**
+     * Merge post `number` into `intoNumber`: votes move (one per user), comments and follows move, the old
+     * number redirects. There is no unmerge. Refusals: `same_post`, `not_found`, `already_merged`,
+     * `target_merged`, `deleted`, `busy`.
+     */
+    createFeedbackMerge({ auth, number, intoNumber }: AdminFeedbackFunctionsInput['createFeedbackMerge']): Promise<import("../types").WebResponse<{
+        post: AdminFeedbackPost | null;
+        movedVotes: number;
+    }>>;
+    getAdminFeedbackBoards({ auth }: AdminFeedbackFunctionsInput['getAdminFeedbackBoards']): Promise<import("../types").WebResponse<{
+        boards: AdminFeedbackBoard[];
+    }>>;
+    /** Developers only. `minTierId` needs `audience: 'premium'` and a paid guild plan. */
+    createFeedbackBoard({ auth, board }: AdminFeedbackFunctionsInput['createFeedbackBoard']): Promise<import("../types").WebResponse<{
+        boardId: string;
+    }>>;
+    updateFeedbackBoard({ auth, boardId, board }: AdminFeedbackFunctionsInput['updateFeedbackBoard']): Promise<import("../types").WebResponse<{
+        boardId: string;
+    }>>;
+    /** Only an empty board (`board_has_posts` otherwise - archive it instead). */
+    deleteFeedbackBoard({ auth, boardId }: AdminFeedbackFunctionsInput['deleteFeedbackBoard']): Promise<import("../types").WebResponse<{
+        deleted: true;
+    }>>;
+    /** Every tag, hidden ones included. */
+    getAdminFeedbackTags({ auth }: AdminFeedbackFunctionsInput['getAdminFeedbackTags']): Promise<import("../types").WebResponse<{
+        tags: Array<{
+            tagId: string;
+            slug: string;
+            name: string;
+            color: string;
+            hidden: boolean;
+        }>;
+    }>>;
+    createFeedbackTag({ auth, tag }: AdminFeedbackFunctionsInput['createFeedbackTag']): Promise<import("../types").WebResponse<{
+        tagId: string;
+    }>>;
+    /** Tags are hidden, never deleted. */
+    updateFeedbackTag({ auth, tagId, tag }: AdminFeedbackFunctionsInput['updateFeedbackTag']): Promise<import("../types").WebResponse<{
+        tagId: string;
+    }>>;
+    /** Active bans (`all: true` includes expired), optionally for one `userId`. */
+    getFeedbackBans({ auth, ...query }: AdminFeedbackFunctionsInput['getFeedbackBans']): Promise<import("../types").WebResponse<{
+        bans: FeedbackBan[];
+    }>>;
+    /** Ban a user from posting, commenting (and reacting), voting, or all of it. Survives their data deletion. */
+    createFeedbackBan({ auth, ban }: AdminFeedbackFunctionsInput['createFeedbackBan']): Promise<import("../types").WebResponse<{
+        banId: string;
+    }>>;
+    deleteFeedbackBan({ auth, banId }: AdminFeedbackFunctionsInput['deleteFeedbackBan']): Promise<import("../types").WebResponse<{
+        deleted: true;
+    }>>;
+    /**
+     * Comment as staff: `internal` for a staff-only note (a reply under a note is a note too), `official` for the
+     * pinned answer (replaces the current one; never a note, never a reply). Returns the full thread incl. notes.
+     */
+    createAdminFeedbackComment({ auth, number, comment }: AdminFeedbackFunctionsInput['createAdminFeedbackComment']): Promise<import("../types").WebResponse<FeedbackThread>>;
+    /** Hide / unhide a comment, or make it (or stop it being) the official answer. */
+    updateAdminFeedbackComment({ auth, commentId, comment }: AdminFeedbackFunctionsInput['updateAdminFeedbackComment']): Promise<import("../types").WebResponse<FeedbackThread>>;
+    /** The staff action log, newest first. `target` filters, e.g. `post:42`, `board:<id>`, `user:<discordId>`. */
+    getFeedbackAudits({ auth, ...query }: AdminFeedbackFunctionsInput['getFeedbackAudits']): Promise<import("../types").WebResponse<{
+        audits: FeedbackAudit[];
+        offset: number;
+        limit: number;
+    }>>;
+}
+export type AdminFeedbackFunctionsInput = {
+    'getAdminFeedbackPosts': {
+        auth: string;
+        status?: FeedbackStatus;
+        boardId?: string;
+        q?: string;
+        hidden?: boolean;
+        deleted?: boolean;
+        merged?: boolean;
+        sort?: 'new' | 'top';
+        offset?: number;
+        limit?: number;
+    };
+    'getAdminFeedbackPost': {
+        auth: string;
+        number: number;
+    };
+    'updateAdminFeedbackPost': {
+        auth: string;
+        number: number;
+        post: AdminFeedbackPostUpdate;
+    };
+    'deleteAdminFeedbackPost': {
+        auth: string;
+        number: number;
+    };
+    'createFeedbackMerge': {
+        auth: string;
+        number: number;
+        intoNumber: number;
+    };
+    'getAdminFeedbackBoards': {
+        auth: string;
+    };
+    'createFeedbackBoard': {
+        auth: string;
+        board: FeedbackBoardInput;
+    };
+    'updateFeedbackBoard': {
+        auth: string;
+        boardId: string;
+        board: Partial<FeedbackBoardInput>;
+    };
+    'deleteFeedbackBoard': {
+        auth: string;
+        boardId: string;
+    };
+    'getAdminFeedbackTags': {
+        auth: string;
+    };
+    'createFeedbackTag': {
+        auth: string;
+        tag: {
+            slug: string;
+            name: string;
+            color: string;
+            hidden?: boolean;
+        };
+    };
+    'updateFeedbackTag': {
+        auth: string;
+        tagId: string;
+        tag: {
+            slug?: string;
+            name?: string;
+            color?: string;
+            hidden?: boolean;
+        };
+    };
+    'getFeedbackBans': {
+        auth: string;
+        userId?: string;
+        all?: boolean;
+    };
+    'createFeedbackBan': {
+        auth: string;
+        ban: {
+            userId: string;
+            scope: FeedbackBanScope;
+            reason: string;
+            until?: string | null;
+        };
+    };
+    'deleteFeedbackBan': {
+        auth: string;
+        banId: string;
+    };
+    'getFeedbackAudits': {
+        auth: string;
+        target?: string;
+        offset?: number;
+        limit?: number;
+    };
+    'createAdminFeedbackComment': {
+        auth: string;
+        number: number;
+        comment: {
+            body: string;
+            parentId?: string;
+            uploadIds?: string[];
+            internal?: boolean;
+            official?: boolean;
+        };
+    };
+    'updateAdminFeedbackComment': {
+        auth: string;
+        commentId: string;
+        comment: {
+            hidden?: boolean;
+            official?: boolean;
+        };
+    };
+};
+export type AdminFeedbackGetReturnTypes = {
+    'getAdminFeedbackPostsRaw': Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackPosts']>>;
+    'getAdminFeedbackPostsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackPosts']>>>;
+    'getAdminFeedbackPostRaw': Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackPost']>>;
+    'getAdminFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackPost']>>>;
+    'updateAdminFeedbackPostRaw': Awaited<ReturnType<APIAdminFeedback['updateAdminFeedbackPost']>>;
+    'updateAdminFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['updateAdminFeedbackPost']>>>;
+    'deleteAdminFeedbackPostRaw': Awaited<ReturnType<APIAdminFeedback['deleteAdminFeedbackPost']>>;
+    'deleteAdminFeedbackPostSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['deleteAdminFeedbackPost']>>>;
+    'createFeedbackMergeRaw': Awaited<ReturnType<APIAdminFeedback['createFeedbackMerge']>>;
+    'createFeedbackMergeSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['createFeedbackMerge']>>>;
+    'getAdminFeedbackBoardsRaw': Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackBoards']>>;
+    'getAdminFeedbackBoardsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackBoards']>>>;
+    'createFeedbackBoardRaw': Awaited<ReturnType<APIAdminFeedback['createFeedbackBoard']>>;
+    'createFeedbackBoardSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['createFeedbackBoard']>>>;
+    'updateFeedbackBoardRaw': Awaited<ReturnType<APIAdminFeedback['updateFeedbackBoard']>>;
+    'updateFeedbackBoardSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['updateFeedbackBoard']>>>;
+    'deleteFeedbackBoardRaw': Awaited<ReturnType<APIAdminFeedback['deleteFeedbackBoard']>>;
+    'deleteFeedbackBoardSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['deleteFeedbackBoard']>>>;
+    'getAdminFeedbackTagsRaw': Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackTags']>>;
+    'getAdminFeedbackTagsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['getAdminFeedbackTags']>>>;
+    'createFeedbackTagRaw': Awaited<ReturnType<APIAdminFeedback['createFeedbackTag']>>;
+    'createFeedbackTagSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['createFeedbackTag']>>>;
+    'updateFeedbackTagRaw': Awaited<ReturnType<APIAdminFeedback['updateFeedbackTag']>>;
+    'updateFeedbackTagSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['updateFeedbackTag']>>>;
+    'getFeedbackBansRaw': Awaited<ReturnType<APIAdminFeedback['getFeedbackBans']>>;
+    'getFeedbackBansSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['getFeedbackBans']>>>;
+    'createFeedbackBanRaw': Awaited<ReturnType<APIAdminFeedback['createFeedbackBan']>>;
+    'createFeedbackBanSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['createFeedbackBan']>>>;
+    'deleteFeedbackBanRaw': Awaited<ReturnType<APIAdminFeedback['deleteFeedbackBan']>>;
+    'deleteFeedbackBanSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['deleteFeedbackBan']>>>;
+    'getFeedbackAuditsRaw': Awaited<ReturnType<APIAdminFeedback['getFeedbackAudits']>>;
+    'getFeedbackAuditsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['getFeedbackAudits']>>>;
+    'createAdminFeedbackCommentRaw': Awaited<ReturnType<APIAdminFeedback['createAdminFeedbackComment']>>;
+    'createAdminFeedbackCommentSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['createAdminFeedbackComment']>>>;
+    'updateAdminFeedbackCommentRaw': Awaited<ReturnType<APIAdminFeedback['updateAdminFeedbackComment']>>;
+    'updateAdminFeedbackCommentSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdminFeedback['updateAdminFeedbackComment']>>>;
+};
+/** Mirrors `FeedbackBanScopeEnum`. `comment` also covers reactions. */
+export declare const FEEDBACK_BAN_SCOPES: readonly ["post", "comment", "vote", "all"];
+export type FeedbackBanScope = typeof FEEDBACK_BAN_SCOPES[number];
+export type AdminFeedbackPost = FeedbackPost & {
+    /** Discord id of the author; null for imported / deleted-user posts. */
+    authorId: string | null;
+    audienceOverride: FeedbackAudience | null;
+    featuredAt: string | null;
+    featuredOrder: number | null;
+    featuredUntil: string | null;
+    deletedAt: string | null;
+};
+export type AdminFeedbackPostUpdate = {
+    status?: FeedbackStatus;
+    declinedReason?: string | null;
+    eta?: string | null;
+    tagIds?: string[];
+    boardId?: string;
+    audienceOverride?: FeedbackAudience | null;
+    pinned?: boolean;
+    hidden?: boolean;
+    hiddenReason?: string | null;
+    featured?: boolean;
+    featuredOrder?: number | null;
+    /** ISO, or null for no end. */
+    featuredUntil?: string | null;
+    votingLocked?: boolean;
+    commentsLocked?: boolean;
+    deleted?: boolean;
+    /** A changelog entry (its dbId) this shipped in; shown on the timeline once that changelog is public. `invalid_changelog` if unknown. */
+    changelogId?: string | null;
+    /** Developers only. */
+    title?: string;
+    /** Developers only. */
+    body?: string;
+};
+export type FeedbackVoteBreakdown = {
+    votes: number;
+    /** Plan name -> votes, e.g. `{ Free: 30, 'Server Premium': 4 }`. */
+    byTier: Record<string, number>;
+    /** Sum of member counts of the voters' premium servers at vote time. */
+    memberReach: number;
+    newAccounts: number;
+    /** 0..1 - a high share from accounts under 30 days old is worth a second look. */
+    newAccountShare: number;
+};
+export type FeedbackBoardInput = {
+    slug: string;
+    name: string;
+    description?: string | null;
+    audience?: FeedbackAudience;
+    /** A paid guild plan's tierId; needs audience 'premium'. Null = any paid plan. */
+    minTierId?: string | null;
+    position?: number;
+    hidden?: boolean;
+    archived?: boolean;
+    postingOpen?: boolean;
+    /** What new posts in this board default to, e.g. 'authorAndStaff' for a bug board. Must narrow `audience`. */
+    defaultPostAudience?: FeedbackAudience | null;
+};
+export type AdminFeedbackBoard = Required<Omit<FeedbackBoardInput, 'description' | 'minTierId' | 'defaultPostAudience'>> & {
+    boardId: string;
+    description: string | null;
+    minTierId: string | null;
+    defaultPostAudience: FeedbackAudience | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type FeedbackBan = {
+    banId: string;
+    userId: string;
+    scope: FeedbackBanScope;
+    reason: string;
+    until: string | null;
+    createdBy: string;
+    createdAt: string;
+};
+export type FeedbackAudit = {
+    auditId: string;
+    actorId: string;
+    action: string;
+    target: string;
+    before: unknown;
+    after: unknown;
+    createdAt: string;
+};

package/dist/classes/adminFeedback.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEEDBACK_BAN_SCOPES = exports.APIAdminFeedback = void 0;
+// Data.
+/**
+ * The feedback board - the staff side. Post moderation, tags and bans are staff + developers; boards (and
+ * rewriting a post's `title` / `body`) are developers only (403 otherwise). None is behind the `feedback`
+ * flag, so boards can be set up before launch. Every change is written to the audit log (`getFeedbackAudits`).
+ */
+class APIAdminFeedback {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    /** Every post incl. hidden / private. `deleted: true` lists deleted ones instead; `merged: true` includes merged ones. */
+    async getAdminFeedbackPosts({ auth, ...query }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/feedback/posts', query),
+        });
+    }
+    /** One post with who wants it: votes by plan, voters' server reach, share from accounts under 30 days. */
+    async getAdminFeedbackPost({ auth, number }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/feedback/posts/' + number),
+        });
+    }
+    /**
+     * Moderate a post; send only what changes. `status: 'done'` sets `shippedAt`. `audienceOverride` may only
+     * narrow the board (`audience_widens_board`). `featured` puts it on the main page (until `featuredUntil`).
+     * `deleted` soft-deletes / restores. `title` / `body` are developers only.
+     */
+    async updateAdminFeedbackPost({ auth, number, post }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/admin/feedback/posts/' + number),
+            body: post,
+        });
+    }
+    async deleteAdminFeedbackPost({ auth, number }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/admin/feedback/posts/' + number),
+        });
+    }
+    /**
+     * Merge post `number` into `intoNumber`: votes move (one per user), comments and follows move, the old
+     * number redirects. There is no unmerge. Refusals: `same_post`, `not_found`, `already_merged`,
+     * `target_merged`, `deleted`, `busy`.
+     */
+    async createFeedbackMerge({ auth, number, intoNumber }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/admin/feedback/posts/' + number + '/merges'),
+            body: { intoNumber },
+        });
+    }
+    async getAdminFeedbackBoards({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/feedback/boards'),
+        });
+    }
+    /** Developers only. `minTierId` needs `audience: 'premium'` and a paid guild plan. */
+    async createFeedbackBoard({ auth, board }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/admin/feedback/boards'),
+            body: board,
+        });
+    }
+    async updateFeedbackBoard({ auth, boardId, board }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/admin/feedback/boards/' + boardId),
+            body: board,
+        });
+    }
+    /** Only an empty board (`board_has_posts` otherwise - archive it instead). */
+    async deleteFeedbackBoard({ auth, boardId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/admin/feedback/boards/' + boardId),
+        });
+    }
+    /** Every tag, hidden ones included. */
+    async getAdminFeedbackTags({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/feedback/tags'),
+        });
+    }
+    async createFeedbackTag({ auth, tag }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/admin/feedback/tags'),
+            body: tag,
+        });
+    }
+    /** Tags are hidden, never deleted. */
+    async updateFeedbackTag({ auth, tagId, tag }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/admin/feedback/tags/' + tagId),
+            body: tag,
+        });
+    }
+    /** Active bans (`all: true` includes expired), optionally for one `userId`. */
+    async getFeedbackBans({ auth, ...query }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/feedback/bans', query),
+        });
+    }
+    /** Ban a user from posting, commenting (and reacting), voting, or all of it. Survives their data deletion. */
+    async createFeedbackBan({ auth, ban }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/admin/feedback/bans'),
+            body: ban,
+        });
+    }
+    async deleteFeedbackBan({ auth, banId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/admin/feedback/bans/' + banId),
+        });
+    }
+    /**
+     * Comment as staff: `internal` for a staff-only note (a reply under a note is a note too), `official` for the
+     * pinned answer (replaces the current one; never a note, never a reply). Returns the full thread incl. notes.
+     */
+    async createAdminFeedbackComment({ auth, number, comment }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/admin/feedback/posts/' + number + '/comments'),
+            body: comment,
+        });
+    }
+    /** Hide / unhide a comment, or make it (or stop it being) the official answer. */
+    async updateAdminFeedbackComment({ auth, commentId, comment }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp('/admin/feedback/comments/' + commentId),
+            body: comment,
+        });
+    }
+    /** The staff action log, newest first. `target` filters, e.g. `post:42`, `board:<id>`, `user:<discordId>`. */
+    async getFeedbackAudits({ auth, ...query }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/feedback/audits', query),
+        });
+    }
+}
+exports.APIAdminFeedback = APIAdminFeedback;
+/** Mirrors `FeedbackBanScopeEnum`. `comment` also covers reactions. */
+exports.FEEDBACK_BAN_SCOPES = ['post', 'comment', 'vote', 'all'];

package/dist/classes/adminPolls.d.ts

@@ -94,17 +94,21 @@ export type SitePollCreateInput = {
     closesAt?: Date | string | null;
     /** Default false. */
     postToDiscord?: boolean;
+    /** `feedbackPostNumber` links the option to a PUBLIC feedback post (`{ code: 'post_not_public', number }` otherwise). */
     options: Array<{
         label: string;
         description?: string | null;
+        feedbackPostNumber?: number | null;
     }>;
 };
 /** Mirrors `SitePollUpdateSchema` in Noti-v3. */
 export type SitePollUpdateInput = Partial<Omit<SitePollCreateInput, 'options'>> & {
+    /** Replaces the list - an option sent without `feedbackPostNumber` is unlinked. */
     options?: Array<{
         optionId?: string;
         label: string;
         description?: string | null;
+        feedbackPostNumber?: number | null;
     }>;
     /** Allow removing options that have votes (their votes are deleted). */
     force?: boolean;