@fulldivevr/workcord-cli 1.0.0

package/dist/generated/commands/google-play-iap.js

@@ -0,0 +1,73 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "google-play-iap", "GooglePlayIap operations");
+    if (!hasSubcommand(group, "verify")) {
+        group
+            .command("verify")
+            .description("POST /api/v1/subscriptions/google/verify")
+            .requiredOption("--purchase-token <value>", "string")
+            .requiredOption("--product-id <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/subscriptions/google/verify`;
+            const body = {};
+            {
+                const v = opts.purchaseToken;
+                if (v !== undefined)
+                    body["purchaseToken"] = v;
+            }
+            {
+                const v = opts.productId;
+                if (v !== undefined)
+                    body["productId"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "restore")) {
+        group
+            .command("restore")
+            .description("POST /api/v1/subscriptions/google/restore")
+            .requiredOption("--purchase-token <value>", "string")
+            .requiredOption("--product-id <value>", "string")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/subscriptions/google/restore`;
+            const body = {};
+            {
+                const v = opts.purchaseToken;
+                if (v !== undefined)
+                    body["purchaseToken"] = v;
+            }
+            {
+                const v = opts.productId;
+                if (v !== undefined)
+                    body["productId"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "webhook")) {
+        group
+            .command("webhook")
+            .description("POST /api/v1/webhooks/google-play")
+            .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/webhooks/google-play`;
+            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=google-play-iap.js.map

package/dist/generated/commands/health.js

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

package/dist/generated/commands/internal.js

@@ -0,0 +1,162 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "internal", "Internal operations");
+    if (!hasSubcommand(group, "emit-message")) {
+        group
+            .command("emit-message")
+            .description("POST /api/v1/internal/rooms/{roomId}/emit-message")
+            .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/internal/rooms/${encodeURIComponent(opts.roomId)}/emit-message`;
+            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, "voice-dispatch")) {
+        group
+            .command("voice-dispatch")
+            .description("POST /api/v1/internal/voice/dispatch")
+            .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/internal/voice/dispatch`;
+            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-users")) {
+        group
+            .command("list-users")
+            .description("GET /api/v1/internal/users")
+            .option("--cursor <value>", "string")
+            .option("--account-type <value>", "string")
+            .option("--limit <json>", " (JSON)")
+            .option("--q <json>", " (JSON)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/internal/users`;
+            const query = {};
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.accountType;
+                if (v !== undefined)
+                    query["accountType"] = v;
+            }
+            {
+                const v = opts.limit === undefined ? undefined : JSON.parse(opts.limit);
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            {
+                const v = opts.q === undefined ? undefined : JSON.parse(opts.q);
+                if (v !== undefined)
+                    query["q"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "set-tier")) {
+        group
+            .command("set-tier")
+            .description("POST /api/v1/internal/users/{userId}/tier")
+            .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/internal/users/${encodeURIComponent(opts.userId)}/tier`;
+            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-email-allowlist")) {
+        group
+            .command("list-email-allowlist")
+            .description("GET /api/v1/internal/email-auth/allowlist")
+            .option("--limit <json>", " (JSON)")
+            .option("--q <json>", " (JSON)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/internal/email-auth/allowlist`;
+            const query = {};
+            {
+                const v = opts.limit === undefined ? undefined : JSON.parse(opts.limit);
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            {
+                const v = opts.q === undefined ? undefined : JSON.parse(opts.q);
+                if (v !== undefined)
+                    query["q"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "upsert-email-allowlist")) {
+        group
+            .command("upsert-email-allowlist")
+            .description("POST /api/v1/internal/email-auth/allowlist")
+            .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/internal/email-auth/allowlist`;
+            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, "patch-email-allowlist")) {
+        group
+            .command("patch-email-allowlist")
+            .description("PATCH /api/v1/internal/email-auth/allowlist/{email}")
+            .requiredOption("--email <value>", "email (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/internal/email-auth/allowlist/${encodeURIComponent(opts.email)}`;
+            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");
+        });
+    }
+    if (!hasSubcommand(group, "delete-email-allowlist")) {
+        group
+            .command("delete-email-allowlist")
+            .description("DELETE /api/v1/internal/email-auth/allowlist/{email}")
+            .requiredOption("--email <value>", "email (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/internal/email-auth/allowlist/${encodeURIComponent(opts.email)}`;
+            const data = await call({ method: "DELETE", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=internal.js.map

package/dist/generated/commands/interview.js

@@ -0,0 +1,76 @@
+// Auto-generated. Do not edit by hand. Regenerate via `npm run generate`.
+import { Option } from "commander";
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "interview", "Interview operations");
+    if (!hasSubcommand(group, "start")) {
+        group
+            .command("start")
+            .description("POST /api/v1/assistant/interview/start")
+            .addOption(new Option("--mode <value>", "string, enum").choices(["room", "agent"]).makeOptionMandatory())
+            .option("--seed <value>", "string, ≤10000 chars")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/assistant/interview/start`;
+            const body = {};
+            {
+                const v = opts.mode;
+                if (v !== undefined)
+                    body["mode"] = v;
+            }
+            {
+                const v = opts.seed;
+                if (v !== undefined)
+                    body["seed"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "reply")) {
+        group
+            .command("reply")
+            .description("POST /api/v1/assistant/interview/{sessionId}/reply")
+            .requiredOption("--session-id <value>", "sessionId (path param)")
+            .requiredOption("--message <value>", "string, ≤10000 chars")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/assistant/interview/${encodeURIComponent(opts.sessionId)}/reply`;
+            const body = {};
+            {
+                const v = opts.message;
+                if (v !== undefined)
+                    body["message"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "confirm")) {
+        group
+            .command("confirm")
+            .description("POST /api/v1/assistant/interview/{sessionId}/confirm")
+            .requiredOption("--session-id <value>", "sessionId (path param)")
+            .requiredOption("--proposal <json>", " (JSON)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/assistant/interview/${encodeURIComponent(opts.sessionId)}/confirm`;
+            const body = {};
+            {
+                const v = opts.proposal === undefined ? undefined : JSON.parse(opts.proposal);
+                if (v !== undefined)
+                    body["proposal"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=interview.js.map

package/dist/generated/commands/invite-redirect.js

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

package/dist/generated/commands/jesuscord-admin.js

@@ -0,0 +1,36 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "jesuscord-admin", "JesuscordAdmin operations");
+    if (!hasSubcommand(group, "setup")) {
+        group
+            .command("setup")
+            .description("POST /api/v1/admin/jesuscord/setup")
+            .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/admin/jesuscord/setup`;
+            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, "cleanup")) {
+        group
+            .command("cleanup")
+            .description("POST /api/v1/admin/jesuscord/cleanup")
+            .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/admin/jesuscord/cleanup`;
+            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=jesuscord-admin.js.map

package/dist/generated/commands/join.js

@@ -0,0 +1,27 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "join", "Join operations");
+    if (!hasSubcommand(group, "join-page")) {
+        group
+            .command("join-page")
+            .description("GET /join/{code}")
+            .requiredOption("--code <value>", "code (path param)")
+            .option("--ref <json>", " (JSON)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/join/${encodeURIComponent(opts.code)}`;
+            const query = {};
+            {
+                const v = opts.ref === undefined ? undefined : JSON.parse(opts.ref);
+                if (v !== undefined)
+                    query["ref"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=join.js.map

package/dist/generated/commands/kits.js

@@ -0,0 +1,108 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "kits", "Kits operations");
+    if (!hasSubcommand(group, "list-mine")) {
+        group
+            .command("list-mine")
+            .description("GET /api/v1/users/me/kits")
+            .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/kits`;
+            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, "approve")) {
+        group
+            .command("approve")
+            .description("POST /api/v1/kits/{kitId}/approve")
+            .requiredOption("--kit-id <value>", "kitId (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/kits/${encodeURIComponent(opts.kitId)}/approve`;
+            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-element")) {
+        group
+            .command("remove-element")
+            .description("DELETE /api/v1/kits/{kitId}/elements/{elementId}")
+            .requiredOption("--kit-id <value>", "kitId (path param)")
+            .requiredOption("--element-id <value>", "elementId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/kits/${encodeURIComponent(opts.kitId)}/elements/${encodeURIComponent(opts.elementId)}`;
+            const data = await call({ method: "DELETE", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "public-kit")) {
+        group
+            .command("public-kit")
+            .description("GET /api/v1/kits/{kitId}/public")
+            .requiredOption("--kit-id <value>", "kitId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/kits/${encodeURIComponent(opts.kitId)}/public`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "public-element")) {
+        group
+            .command("public-element")
+            .description("GET /api/v1/kits/{kitId}/elements/{elementId}/public")
+            .requiredOption("--kit-id <value>", "kitId (path param)")
+            .requiredOption("--element-id <value>", "elementId (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/kits/${encodeURIComponent(opts.kitId)}/elements/${encodeURIComponent(opts.elementId)}/public`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "share-proof-dm")) {
+        group
+            .command("share-proof-dm")
+            .description("POST /api/v1/jesuscord/pastors/{pastorId}/share-proof-dm")
+            .requiredOption("--pastor-id <value>", "pastorId (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/jesuscord/pastors/${encodeURIComponent(opts.pastorId)}/share-proof-dm`;
+            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=kits.js.map

package/dist/generated/commands/meetings.js

@@ -0,0 +1,81 @@
+import { call } from "../../client.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "meetings", "Meetings operations");
+    if (!hasSubcommand(group, "create")) {
+        group
+            .command("create")
+            .description("POST /api/v1/meetings")
+            .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/meetings`;
+            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, "trial-status")) {
+        group
+            .command("trial-status")
+            .description("GET /api/v1/meetings/trial")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/meetings/trial`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "upload-chunk")) {
+        group
+            .command("upload-chunk")
+            .description("POST /api/v1/meetings/{id}/chunks/{index}")
+            .requiredOption("--id <value>", "id (path param)")
+            .requiredOption("--index <value>", "index (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/meetings/${encodeURIComponent(opts.id)}/chunks/${encodeURIComponent(opts.index)}`;
+            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, "complete")) {
+        group
+            .command("complete")
+            .description("POST /api/v1/meetings/{id}/complete")
+            .requiredOption("--id <value>", "id (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/meetings/${encodeURIComponent(opts.id)}/complete`;
+            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, "transcript")) {
+        group
+            .command("transcript")
+            .description("GET /api/v1/meetings/{id}/transcript")
+            .requiredOption("--id <value>", "id (path param)")
+            .action(async (opts) => {
+            const { as } = program.opts();
+            if (!as)
+                throw new Error("--as <userId> is required");
+            const path = `/api/v1/meetings/${encodeURIComponent(opts.id)}/transcript`;
+            const data = await call({ method: "GET", path, asUserId: as });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=meetings.js.map