@fulldivevr/workcord-cli 1.0.0

package/dist/generated/commands/discover.js

@@ -0,0 +1,236 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "discover", "Discover operations");
+    if (!hasSubcommand(group, "tags")) {
+        group
+            .command("tags")
+            .description("GET /api/v1/discover/tags")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/tags`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "discover-rooms")) {
+        group
+            .command("discover-rooms")
+            .description("GET /api/v1/discover/rooms")
+            .option("--category <value>", "string")
+            .option("--language <value>", "string")
+            .option("--search <value>", "string")
+            .option("--tags <value>", "string")
+            .option("--sort <value>", "string")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .option("--page <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/rooms`;
+            const query = {};
+            {
+                const v = opts.category;
+                if (v !== undefined)
+                    query["category"] = v;
+            }
+            {
+                const v = opts.language;
+                if (v !== undefined)
+                    query["language"] = v;
+            }
+            {
+                const v = opts.search;
+                if (v !== undefined)
+                    query["search"] = v;
+            }
+            {
+                const v = opts.tags;
+                if (v !== undefined)
+                    query["tags"] = v;
+            }
+            {
+                const v = opts.sort;
+                if (v !== undefined)
+                    query["sort"] = v;
+            }
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            {
+                const v = opts.page;
+                if (v !== undefined)
+                    query["page"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "trending-rooms")) {
+        group
+            .command("trending-rooms")
+            .description("GET /api/v1/discover/rooms/trending")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/rooms/trending`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "room-by-slug")) {
+        group
+            .command("room-by-slug")
+            .description("GET /api/v1/discover/rooms/by-slug/{slug}")
+            .requiredOption("--slug <value>", "slug (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/rooms/by-slug/${encodeURIComponent(opts.slug)}`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "trending-stories")) {
+        group
+            .command("trending-stories")
+            .description("GET /api/v1/discover/stories/trending")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/stories/trending`;
+            const query = {};
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "enriched-rooms")) {
+        group
+            .command("enriched-rooms")
+            .description("GET /api/v1/discover/rooms/enriched")
+            .option("--category <value>", "string")
+            .option("--language <value>", "string")
+            .option("--search <value>", "string")
+            .option("--tags <value>", "string")
+            .option("--sort <value>", "string")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .option("--page <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/rooms/enriched`;
+            const query = {};
+            {
+                const v = opts.category;
+                if (v !== undefined)
+                    query["category"] = v;
+            }
+            {
+                const v = opts.language;
+                if (v !== undefined)
+                    query["language"] = v;
+            }
+            {
+                const v = opts.search;
+                if (v !== undefined)
+                    query["search"] = v;
+            }
+            {
+                const v = opts.tags;
+                if (v !== undefined)
+                    query["tags"] = v;
+            }
+            {
+                const v = opts.sort;
+                if (v !== undefined)
+                    query["sort"] = v;
+            }
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            {
+                const v = opts.page;
+                if (v !== undefined)
+                    query["page"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "active-challenges")) {
+        group
+            .command("active-challenges")
+            .description("GET /api/v1/discover/challenges/active")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/challenges/active`;
+            const query = {};
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "templates")) {
+        group
+            .command("templates")
+            .description("GET /api/v1/discover/templates")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/discover/templates`;
+            const query = {};
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=discover.js.map

package/dist/generated/commands/dm.js

@@ -0,0 +1,155 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "dm", "Dm operations");
+    if (!hasSubcommand(group, "start-dm")) {
+        group
+            .command("start-dm")
+            .description("POST /api/v1/dm/start")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/start`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "start-agent-dm")) {
+        group
+            .command("start-agent-dm")
+            .description("POST /api/v1/dm/start-agent")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/start-agent`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "list-dms")) {
+        group
+            .command("list-dms")
+            .description("GET /api/v1/dm")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .option("--include-shadow <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm`;
+            const query = {};
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            {
+                const v = opts.includeShadow;
+                if (v !== undefined)
+                    query["includeShadow"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "block-user")) {
+        group
+            .command("block-user")
+            .description("POST /api/v1/dm/block/{userId}")
+            .requiredOption("--user-id <value>", "userId (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/block/${encodeURIComponent(opts.userId)}`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "unblock-user")) {
+        group
+            .command("unblock-user")
+            .description("DELETE /api/v1/dm/block/{userId}")
+            .requiredOption("--user-id <value>", "userId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/block/${encodeURIComponent(opts.userId)}`;
+            const data = await call({ method: "DELETE", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "list-blocked-users")) {
+        group
+            .command("list-blocked-users")
+            .description("GET /api/v1/dm/blocked")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/blocked`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "check-block")) {
+        group
+            .command("check-block")
+            .description("GET /api/v1/dm/check-block/{userId}")
+            .requiredOption("--user-id <value>", "userId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/check-block/${encodeURIComponent(opts.userId)}`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "clear-messages")) {
+        group
+            .command("clear-messages")
+            .description("POST /api/v1/dm/rooms/{roomId}/clear")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/rooms/${encodeURIComponent(opts.roomId)}/clear`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "remove-room")) {
+        group
+            .command("remove-room")
+            .description("DELETE /api/v1/dm/rooms/{roomId}")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/dm/rooms/${encodeURIComponent(opts.roomId)}`;
+            const data = await call({ method: "DELETE", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=dm.js.map

package/dist/generated/commands/drafts.js

@@ -0,0 +1,41 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "drafts", "Drafts operations");
+    if (!hasSubcommand(group, "list")) {
+        group
+            .command("list")
+            .description("GET /api/v1/drafts")
+            .option("--room-id <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/drafts`;
+            const query = {};
+            {
+                const v = opts.roomId;
+                if (v !== undefined)
+                    query["roomId"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "save")) {
+        group
+            .command("save")
+            .description("PATCH /api/v1/drafts")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/drafts`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "PATCH", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=drafts.js.map

package/dist/generated/commands/embed.js

@@ -0,0 +1,34 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "embed", "Embed operations");
+    if (!hasSubcommand(group, "embed-story")) {
+        group
+            .command("embed-story")
+            .description("GET /embed/{storyId}")
+            .requiredOption("--story-id <value>", "storyId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/embed/${encodeURIComponent(opts.storyId)}`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "embed-snippet")) {
+        group
+            .command("embed-snippet")
+            .description("GET /embed/{storyId}/snippet")
+            .requiredOption("--story-id <value>", "storyId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/embed/${encodeURIComponent(opts.storyId)}/snippet`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=embed.js.map

package/dist/generated/commands/explore.js

@@ -0,0 +1,19 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "explore", "Explore operations");
+    if (!hasSubcommand(group, "explore-page")) {
+        group
+            .command("explore-page")
+            .description("GET /explore")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/explore`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=explore.js.map

package/dist/generated/commands/feed.js

@@ -0,0 +1,67 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "feed", "Feed operations");
+    if (!hasSubcommand(group, "get-feed")) {
+        group
+            .command("get-feed")
+            .description("GET /api/v1/users/me/feed")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/feed`;
+            const query = {};
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "get-suggestions")) {
+        group
+            .command("get-suggestions")
+            .description("GET /api/v1/users/me/feed/suggestions")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/feed/suggestions`;
+            const query = {};
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "dismiss")) {
+        group
+            .command("dismiss")
+            .description("POST /api/v1/users/me/feed/dismiss")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/feed/dismiss`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=feed.js.map

package/dist/generated/commands/feedback.js

@@ -0,0 +1,44 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "feedback", "Feedback operations");
+    if (!hasSubcommand(group, "submit")) {
+        group
+            .command("submit")
+            .description("POST /api/v1/feedback")
+            .requiredOption("--type <value>", "string")
+            .requiredOption("--message <value>", "string")
+            .option("--screenshot <value>", "string")
+            .option("--rating <n>", "number")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/feedback`;
+            const body = {};
+            {
+                const v = opts.type;
+                if (v !== undefined)
+                    body["type"] = v;
+            }
+            {
+                const v = opts.message;
+                if (v !== undefined)
+                    body["message"] = v;
+            }
+            {
+                const v = opts.screenshot;
+                if (v !== undefined)
+                    body["screenshot"] = v;
+            }
+            {
+                const v = opts.rating === undefined ? undefined : Number(opts.rating);
+                if (v !== undefined)
+                    body["rating"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=feedback.js.map

package/dist/generated/commands/gamification.js

@@ -0,0 +1,33 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "gamification", "Gamification operations");
+    if (!hasSubcommand(group, "my-impact")) {
+        group
+            .command("my-impact")
+            .description("GET /api/v1/users/me/impact")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/me/impact`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "public-impact")) {
+        group
+            .command("public-impact")
+            .description("GET /api/v1/users/{userId}/impact")
+            .requiredOption("--user-id <value>", "userId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/users/${encodeURIComponent(opts.userId)}/impact`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=gamification.js.map