@curviate/cli 0.14.0 → 0.15.1

package/dist/{post-2JQZ3OSF.js → post-GRIJ7X52.js}

@@ -1,28 +1,35 @@
 #!/usr/bin/env node
-import {
-  AttachError,
-  readAttachment
-} from "./chunk-Q43HZUN3.js";
 import {
   resolveTextOrStdin
 } from "./chunk-U7Y4EXHT.js";
+import {
+  resolveMemberOrMeProviderId
+} from "./chunk-QJZ3LWOX.js";
+import {
+  AttachError,
+  readAttachment,
+  toAttachmentPayload
+} from "./chunk-BGZW6B7G.js";
 import {
   buildPreviewOutput
 } from "./chunk-R3VLWLVV.js";
+import "./chunk-DMQZEPQE.js";
 import {
+  pageDelayFromFlags,
   streamAll
-} from "./chunk-GXTZION6.js";
+} from "./chunk-EEMJDJ4W.js";
 import {
   createClient,
   renderError,
   renderSuccess,
   renderUnexpectedError,
   resolveEffectiveConfig
-} from "./chunk-JXF47TRY.js";
+} from "./chunk-M33MI53G.js";
 import {
   GLOBAL_FLAGS,
-  WRITE_FLAGS
-} from "./chunk-4JHGVY7R.js";
+  WRITE_FLAGS,
+  WRITE_SINGLE_FLAGS
+} from "./chunk-TMU3CSPR.js";
 
 // src/commands/post.ts
 import { defineCommand } from "citty";
@@ -72,39 +79,13 @@ function normalizeAttachPaths(attach) {
 async function handleSdkError(err, outOpts, out) {
   const { CurviateError } = await import("@curviate/sdk");
   if (err instanceof CurviateError) {
-    const { getExitCode } = await import("./exit-codes-ZTY2NY3X.js");
+    const { getExitCode } = await import("./exit-codes-SL3GQF7W.js");
     renderError(err, outOpts, out);
     process.exit(getExitCode(err.code));
   }
   renderUnexpectedError(err, out);
   process.exit(1);
 }
-async function runPostList(client, flags, out) {
-  rejectPreviewOnRead(flags.preview, out);
-  const accountId = requireAccount(flags.account, out);
-  const ns = client.account(accountId);
-  const outOpts = resolveOutputOpts(flags);
-  const all = flags.all ?? false;
-  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
-  const params = buildPaginationParams(flags);
-  try {
-    if (all) {
-      const fn = (p) => ns.posts.list(p);
-      for await (const item of streamAll(fn, params, {
-        maxPages,
-        onTruncated: (n) => out.stderr.write(`Streaming truncated at ${n} page(s). Use --all --max-pages or --cursor for manual paging.
-`)
-      })) {
-        out.stdout.write(JSON.stringify(item) + "\n");
-      }
-    } else {
-      const result = await ns.posts.list(params);
-      renderSuccess(result, outOpts, out);
-    }
-  } catch (err) {
-    await handleSdkError(err, outOpts, out);
-  }
-}
 async function runPostGet(client, flags, out) {
   rejectPreviewOnRead(flags.preview, out);
   rejectAllOnNonPaginated(flags.all, out);
@@ -123,7 +104,6 @@ async function runPostCreate(client, flags, out, _readStdin) {
   const accountId = requireAccount(flags.account, out);
   const rawText = flags.text ?? "";
   const attachPaths = normalizeAttachPaths(flags.attach);
-  const thumbPath = flags["video-thumbnail"];
   const text = await resolveTextOrStdin(rawText, out, _readStdin);
   let attachBuffers = [];
   try {
@@ -136,30 +116,11 @@ async function runPostCreate(client, flags, out, _readStdin) {
     }
     throw err;
   }
-  let thumbBuffer;
-  if (thumbPath) {
-    try {
-      thumbBuffer = await readAttachment(thumbPath);
-    } catch (err) {
-      if (err instanceof AttachError) {
-        out.stderr.write(`error: ${err.message}
-`);
-        process.exit(err.exitCode);
-      }
-      throw err;
-    }
-  }
   if (flags.preview) {
     const allAttachmentPreviews = attachBuffers.map((buf, i) => ({
       name: attachPaths[i] ? attachPaths[i].split("/").pop() ?? attachPaths[i] : `attachment_${i}`,
       buffer: buf
     }));
-    if (thumbBuffer && thumbPath) {
-      allAttachmentPreviews.push({
-        name: `video_thumbnail:${thumbPath.split("/").pop() ?? thumbPath}`,
-        buffer: thumbBuffer
-      });
-    }
     const preview = buildPreviewOutput({
       method: "posts.create",
       args: {},
@@ -170,13 +131,11 @@ async function runPostCreate(client, flags, out, _readStdin) {
     out.stdout.write(JSON.stringify(preview) + "\n");
     return;
   }
-  const body = { text };
-  if (attachBuffers.length > 0) {
-    body["attachments"] = attachBuffers;
-  }
-  if (thumbBuffer) {
-    body["video_thumbnail"] = thumbBuffer;
-  }
+  const attachmentPayloads = attachBuffers.map((buf, i) => toAttachmentPayload(attachPaths[i], buf));
+  const body = {
+    text,
+    ...attachmentPayloads.length > 0 ? { attachments: attachmentPayloads } : {}
+  };
   const ns = client.account(accountId);
   const outOpts = resolveOutputOpts(flags);
   try {
@@ -186,53 +145,43 @@ async function runPostCreate(client, flags, out, _readStdin) {
     await handleSdkError(err, outOpts, out);
   }
 }
-async function runPostComment(client, flags, out, _readStdin) {
+async function runPostReact(client, flags, out) {
   const accountId = requireAccount(flags.account, out);
   const postId = flags.postId ?? "";
-  const rawText = flags.text ?? "";
-  const replyTo = flags["reply-to"];
-  const text = await resolveTextOrStdin(rawText, out, _readStdin);
-  const attachPaths = normalizeAttachPaths(flags.attach);
-  let attachBuffers = [];
-  try {
-    attachBuffers = await Promise.all(attachPaths.map((p) => readAttachment(p)));
-  } catch (err) {
-    if (err instanceof AttachError) {
-      out.stderr.write(`error: ${err.message}
-`);
-      process.exit(err.exitCode);
-    }
-    throw err;
+  const reaction = flags.reaction ?? flags.reactionAlias ?? "";
+  if (!VALID_REACTIONS.has(reaction)) {
+    out.stderr.write(
+      `error: reaction must be one of: like, celebrate, support, love, insightful, funny. Got: "${reaction}"
+`
+    );
+    process.exit(2);
+    return;
   }
-  const body = { text };
-  if (replyTo) body["comment_id"] = replyTo;
+  const asOrganization = flags["as-organization"];
+  const body = {
+    reaction,
+    ...asOrganization ? { react_as: asOrganization } : {}
+  };
   if (flags.preview) {
     const preview = buildPreviewOutput({
-      method: "posts.comment",
+      method: "posts.react",
       args: { post_id: postId },
       body,
-      account: accountId,
-      attachments: attachBuffers.map((buf, i) => ({
-        name: attachPaths[i] ? attachPaths[i].split("/").pop() ?? attachPaths[i] : `attachment_${i}`,
-        buffer: buf
-      }))
+      account: accountId
     });
     out.stdout.write(JSON.stringify(preview) + "\n");
     return;
   }
-  if (attachBuffers.length > 0) {
-    body["attachments"] = attachBuffers;
-  }
   const ns = client.account(accountId);
   const outOpts = resolveOutputOpts(flags);
   try {
-    const result = await ns.posts.comment(postId, body);
+    const result = await ns.posts.react(postId, body);
     renderSuccess(result, outOpts, out);
   } catch (err) {
     await handleSdkError(err, outOpts, out);
   }
 }
-async function runPostComments(client, flags, out) {
+async function runPostReactions(client, flags, out) {
   rejectPreviewOnRead(flags.preview, out);
   const accountId = requireAccount(flags.account, out);
   const postId = flags.postId ?? "";
@@ -241,116 +190,143 @@ async function runPostComments(client, flags, out) {
   const all = flags.all ?? false;
   const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
   const params = buildPaginationParams(flags);
-  if (flags["reply-to"]) params["comment_id"] = flags["reply-to"];
   try {
     if (all) {
-      const fn = (p) => ns.posts.listComments(postId, p);
+      const fn = (p) => ns.posts.listReactions(postId, p);
       for await (const item of streamAll(fn, params, {
         maxPages,
-        onTruncated: (n) => out.stderr.write(`Streaming truncated at ${n} page(s). Use --all --max-pages or --cursor for manual paging.
-`)
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
       })) {
         out.stdout.write(JSON.stringify(item) + "\n");
       }
     } else {
-      const result = await ns.posts.listComments(postId, params);
+      const result = await ns.posts.listReactions(postId, params);
       renderSuccess(result, outOpts, out);
     }
   } catch (err) {
     await handleSdkError(err, outOpts, out);
   }
 }
-async function runPostReact(client, flags, out) {
+async function runPostDelete(client, flags, out) {
+  const accountId = requireAccount(flags.account, out);
+  const postId = flags.postId ?? "";
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "posts.delete", args: { post_id: postId }, body: {}, account: accountId });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.posts.delete(postId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runPostUnreact(client, flags, out) {
   const accountId = requireAccount(flags.account, out);
   const postId = flags.postId ?? "";
   const reaction = flags.reaction ?? "";
   if (!VALID_REACTIONS.has(reaction)) {
     out.stderr.write(
-      `error: --reaction must be one of: like, celebrate, support, love, insightful, funny. Got: "${reaction}"
+      `error: reaction must be one of: like, celebrate, support, love, insightful, funny. Got: "${reaction}"
 `
     );
     process.exit(2);
     return;
   }
-  const commentId = flags["comment-id"];
-  const asOrganization = flags["as-organization"];
-  const body = { reaction };
-  if (commentId) body["comment_id"] = commentId;
-  if (asOrganization) body["as_organization"] = asOrganization;
+  const body = {
+    reaction
+  };
   if (flags.preview) {
-    const preview = buildPreviewOutput({
-      method: "posts.react",
-      args: { post_id: postId },
-      body,
-      account: accountId
-    });
+    const preview = buildPreviewOutput({ method: "posts.unreact", args: { post_id: postId }, body, account: accountId });
     out.stdout.write(JSON.stringify(preview) + "\n");
     return;
   }
   const ns = client.account(accountId);
   const outOpts = resolveOutputOpts(flags);
   try {
-    const result = await ns.posts.react(postId, body);
+    const result = await ns.posts.unreact(postId, body);
     renderSuccess(result, outOpts, out);
   } catch (err) {
     await handleSdkError(err, outOpts, out);
   }
 }
-async function runPostReactions(client, flags, out) {
+async function runPostUserPosts(client, flags, out) {
   rejectPreviewOnRead(flags.preview, out);
   const accountId = requireAccount(flags.account, out);
-  const postId = flags.postId ?? "";
   const ns = client.account(accountId);
   const outOpts = resolveOutputOpts(flags);
+  let userId;
+  try {
+    userId = await resolveMemberOrMeProviderId(ns, flags.userId ?? "");
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+    return;
+  }
   const all = flags.all ?? false;
   const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
   const params = buildPaginationParams(flags);
   try {
     if (all) {
-      const fn = (p) => ns.posts.listReactions(postId, p);
+      const fn = (p) => ns.posts.listUserPosts(userId, p);
       for await (const item of streamAll(fn, params, {
         maxPages,
-        onTruncated: (n) => out.stderr.write(`Streaming truncated at ${n} page(s). Use --all --max-pages or --cursor for manual paging.
-`)
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
       })) {
         out.stdout.write(JSON.stringify(item) + "\n");
       }
     } else {
-      const result = await ns.posts.listReactions(postId, params);
+      const result = await ns.posts.listUserPosts(userId, params);
       renderSuccess(result, outOpts, out);
     }
   } catch (err) {
     await handleSdkError(err, outOpts, out);
   }
 }
-var postListCommand = defineCommand({
-  meta: { name: "list", description: "List posts published by the account." },
-  args: { ...GLOBAL_FLAGS },
-  async run({ args }) {
-    const flags = args;
-    const cfg = await resolveEffectiveConfig({
-      apiKey: flags["api-key"],
-      baseUrl: flags["base-url"],
-      timeout: flags.timeout,
-      account: flags.account,
-      profile: flags.profile
-    });
-    if (!cfg.apiKey) {
-      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
-      process.exit(3);
+async function runPostUserReactions(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  let userId;
+  try {
+    userId = await resolveMemberOrMeProviderId(ns, flags.userId ?? "");
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+    return;
+  }
+  const all = flags.all ?? false;
+  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+  const params = buildPaginationParams(flags);
+  try {
+    if (all) {
+      const fn = (p) => ns.posts.listUserReactions(userId, p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await ns.posts.listUserReactions(userId, params);
+      renderSuccess(result, outOpts, out);
     }
-    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
-    const out = buildOutputStreams();
-    await runPostList(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
   }
-});
+}
 var postGetCommand = defineCommand({
   meta: { name: "get", description: "Get a post by id." },
   args: {
     ...GLOBAL_FLAGS,
     postId: {
       type: "positional",
-      description: "Numeric post id, urn:li:activity:N, or full LinkedIn share URL (activity-<N>- extracted). POSTID is always the post's id. To list replies to a comment, use 'post comments <post_id> --reply-to <comment_id>'."
+      description: "Numeric post id, urn:li:activity:N, or full LinkedIn share URL (activity-<N>- extracted). POSTID is always the post's id. To list comments on a post, use 'comment list <post_id>'."
     }
   },
   async run({ args }) {
@@ -379,11 +355,7 @@ var postCreateCommand = defineCommand({
     text: { type: "positional", description: "Post body text. Pass - to read from stdin (enables multiline via heredoc or pipe)." },
     attach: {
       type: "string",
-      description: "Image/video/document to attach (repeatable for images; use --video-thumbnail when attaching a video). Supported: jpg, png, gif, mp4, pdf."
-    },
-    "video-thumbnail": {
-      type: "string",
-      description: "Thumbnail image for a video attachment (required when attaching a video post)."
+      description: "Image/video/document to attach (repeatable for images; a single PDF produces a document post). Supported: jpg, png, gif, mp4, pdf."
     }
   },
   async run({ args }) {
@@ -404,92 +376,28 @@ var postCreateCommand = defineCommand({
     await runPostCreate(client, { ...flags, account: flags.account ?? cfg.account }, out);
   }
 });
-var postCommentCommand = defineCommand({
-  meta: { name: "comment", description: "Comment on a post, or reply to a comment with --reply-to." },
-  args: {
-    // Write command: WRITE_FLAGS omits pagination/projection flags
-    ...WRITE_FLAGS,
-    postId: {
-      type: "positional",
-      description: "Numeric post id, urn:li:activity:N, or full LinkedIn share URL (activity-<N>- extracted). POSTID is always the post's id; use --reply-to <comment_id> to reply to a specific comment within this post."
-    },
-    text: { type: "positional", description: "Comment text (max ~1,250 characters per LinkedIn limits). Pass - to read from stdin." },
-    attach: { type: "string", description: "Image to attach to the comment (optional; one image per comment)." },
-    "reply-to": {
-      type: "string",
-      description: "Post as a reply to this comment id (omit for a top-level comment on the post)."
-    }
-  },
-  async run({ args }) {
-    const flags = args;
-    const cfg = await resolveEffectiveConfig({
-      apiKey: flags["api-key"],
-      baseUrl: flags["base-url"],
-      timeout: flags.timeout,
-      account: flags.account,
-      profile: flags.profile
-    });
-    if (!cfg.apiKey) {
-      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
-      process.exit(3);
-    }
-    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
-    const out = buildOutputStreams();
-    await runPostComment(client, { ...flags, account: flags.account ?? cfg.account }, out);
-  }
-});
-var postCommentsCommand = defineCommand({
-  meta: { name: "comments", description: "List comments on a post. Use --reply-to to fetch replies to a specific comment." },
-  args: {
-    ...GLOBAL_FLAGS,
-    postId: {
-      type: "positional",
-      description: "Numeric post id, urn:li:activity:N, or full LinkedIn share URL (activity-<N>- extracted). POSTID is always the post's id; to fetch replies to a comment, use --reply-to <comment_id>."
-    },
-    "reply-to": {
-      type: "string",
-      description: "Filter replies under this comment id (omit to list top-level comments on the post)."
-    }
-  },
-  async run({ args }) {
-    const flags = args;
-    const cfg = await resolveEffectiveConfig({
-      apiKey: flags["api-key"],
-      baseUrl: flags["base-url"],
-      timeout: flags.timeout,
-      account: flags.account,
-      profile: flags.profile
-    });
-    if (!cfg.apiKey) {
-      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
-      process.exit(3);
-    }
-    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
-    const out = buildOutputStreams();
-    await runPostComments(client, { ...flags, account: flags.account ?? cfg.account }, out);
-  }
-});
 var postReactCommand = defineCommand({
-  meta: { name: "react", description: "React to a post or comment." },
+  meta: { name: "react", description: "React to a post." },
   args: {
     // Write command: WRITE_FLAGS omits pagination/projection flags
     ...WRITE_FLAGS,
     postId: {
       type: "positional",
-      description: "Numeric post id, urn:li:activity:N, or full LinkedIn share URL (activity-<N>- extracted). POSTID is always the post's id; to react to a comment within the post, use --comment-id <comment_id>."
+      description: "Numeric post id, urn:li:activity:N, or full LinkedIn share URL (activity-<N>- extracted). POSTID is always the post's id."
     },
     reaction: {
-      type: "string",
-      required: true,
+      type: "positional",
+      required: false,
       description: "Write-side reaction (lowercase). Write values: like, celebrate, support, love, insightful, funny. Read-side vocabulary (in the value and user_reacted response fields): LIKE, PRAISE, APPRECIATION, EMPATHY, INTEREST, ENTERTAINMENT. Confirmed write\u2192read mappings: like=LIKE, celebrate=PRAISE, insightful=INTEREST. (support, love, and funny are valid write values; their read-side pairings are unconfirmed.)"
     },
-    "comment-id": {
+    reactionAlias: {
       type: "string",
-      description: "React to this specific comment id within the post (omit to react to the post itself)."
+      alias: "reaction",
+      description: "Deprecated: pass the reaction as the positional <reaction> instead. --reaction still works."
     },
     "as-organization": {
       type: "string",
-      description: "React on behalf of an organization page (org id from 'profile me' organizations)."
+      description: "React on behalf of an organization/company page you administer \u2014 pass that page's numeric id or URN."
     }
   },
   async run({ args }) {
@@ -537,30 +445,89 @@ var postReactionsCommand = defineCommand({
     await runPostReactions(client, { ...flags, account: flags.account ?? cfg.account }, out);
   }
 });
+async function withClient(flags, fn) {
+  const cfg = await resolveEffectiveConfig({
+    apiKey: flags["api-key"],
+    baseUrl: flags["base-url"],
+    timeout: flags.timeout,
+    account: flags.account,
+    profile: flags.profile
+  });
+  if (!cfg.apiKey) {
+    process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+    process.exit(3);
+  }
+  const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+  const out = buildOutputStreams();
+  await fn(client, { ...flags, account: flags.account ?? cfg.account }, out);
+}
+var postDeleteCommand = defineCommand({
+  meta: { name: "delete", description: "Delete a post you own." },
+  args: {
+    ...WRITE_SINGLE_FLAGS,
+    postId: { type: "positional", description: "Post id, urn:li:activity:N, or full share URL." }
+  },
+  async run({ args }) {
+    await withClient(args, runPostDelete);
+  }
+});
+var postUnreactCommand = defineCommand({
+  meta: { name: "unreact", description: "Remove your reaction from a post." },
+  args: {
+    ...WRITE_SINGLE_FLAGS,
+    postId: { type: "positional", description: "Post id, urn:li:activity:N, or full share URL." },
+    reaction: { type: "positional", description: "Reaction to remove: like|celebrate|support|love|insightful|funny." }
+  },
+  async run({ args }) {
+    await withClient(args, runPostUnreact);
+  }
+});
+var postUserPostsCommand = defineCommand({
+  meta: { name: "user-posts", description: "List a member's own posts (accepts 'me'). A very recent create/delete may take a few minutes to appear or clear here (LinkedIn-side indexing); `post get <post_id>` reflects it immediately." },
+  args: {
+    ...GLOBAL_FLAGS,
+    userId: { type: "positional", description: "Member identifier (URL, slug, provider id, or 'me')." }
+  },
+  async run({ args }) {
+    await withClient(args, runPostUserPosts);
+  }
+});
+var postUserReactionsCommand = defineCommand({
+  meta: { name: "user-reactions", description: "List a member's own reactions (accepts 'me')." },
+  args: {
+    ...GLOBAL_FLAGS,
+    userId: { type: "positional", description: "Member identifier (URL, slug, provider id, or 'me')." }
+  },
+  async run({ args }) {
+    await withClient(args, runPostUserReactions);
+  }
+});
 var postCommand = defineCommand({
   meta: { name: "post", description: "Create and manage LinkedIn posts." },
   subCommands: {
-    list: postListCommand,
     get: postGetCommand,
     create: postCreateCommand,
-    comment: postCommentCommand,
-    comments: postCommentsCommand,
     react: postReactCommand,
-    reactions: postReactionsCommand
+    reactions: postReactionsCommand,
+    delete: postDeleteCommand,
+    unreact: postUnreactCommand,
+    "user-posts": postUserPostsCommand,
+    "user-reactions": postUserReactionsCommand
   },
   async run() {
     process.stderr.write(
-      'Usage: curviate post <subcommand>\n  list\n  get <post_id>\n  create "<text>" [--attach <file>\u2026] [--video-thumbnail <file>]\n  comment <post_id> "<text>" [--attach <file>] [--reply-to <comment_id>]\n  comments <post_id> [--reply-to <comment_id>]\n  react <post_id> --reaction <r> [--comment-id <comment_id>] [--as-organization <org_id>]\n  reactions <post_id>\n'
+      'Usage: curviate post <subcommand>\n  get <post_id>\n  create "<text>" [--attach <file>\u2026]\n  react <post_id> <reaction> [--as-organization <org_id>]\n  reactions <post_id>\n  delete <post_id>\n  unreact <post_id> <reaction>\n  user-posts <user_id>\n  user-reactions <user_id>\n\nComment operations moved to the `comment` command group.\n'
     );
   }
 });
 export {
   postCommand,
-  runPostComment,
-  runPostComments,
   runPostCreate,
+  runPostDelete,
   runPostGet,
-  runPostList,
   runPostReact,
-  runPostReactions
+  runPostReactions,
+  runPostUnreact,
+  runPostUserPosts,
+  runPostUserReactions
 };