@sendly/cli 3.37.1 → 3.38.0

package/dist/commands/whatsapp/send.js

@@ -0,0 +1,151 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient, ApiError, AuthenticationError, NotFoundError, } from "../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, formatStatus, formatCredits, } from "../../lib/output.js";
+/** Parse repeatable n=value pairs into a template-variables record. */
+function parseVariables(raw) {
+    if (!raw || raw.length === 0)
+        return undefined;
+    const out = {};
+    for (const item of raw) {
+        const idx = item.indexOf("=");
+        if (idx <= 0) {
+            return `Invalid --var "${item}" — use n=value (e.g. 1=TinyFat)`;
+        }
+        out[item.slice(0, idx).trim()] = item.slice(idx + 1);
+    }
+    return out;
+}
+export default class WhatsappSend extends AuthenticatedCommand {
+    static description = "Send a WhatsApp message — free-form text inside the 24-hour reply window, or an approved template any time";
+    static examples = [
+        '<%= config.bin %> whatsapp send --to +15551234567 --from +15559876543 --text "Your table is ready!"',
+        "<%= config.bin %> whatsapp send --to +447700900123 --from +15559876543 --template order_shipped --language en_US --var 1=TinyFat --var 2=4821",
+        '<%= config.bin %> whatsapp send --to +15551234567 --from +15559876543 --text "Hello!" --json',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        to: Flags.string({
+            char: "t",
+            description: "Recipient phone number (E.164 format)",
+            required: true,
+        }),
+        from: Flags.string({
+            char: "f",
+            description: "Your WhatsApp-connected sender number (E.164 format)",
+            required: true,
+        }),
+        text: Flags.string({
+            char: "m",
+            description: "Free-form message text (only inside the 24-hour reply window)",
+            exclusive: ["template", "language", "var"],
+        }),
+        template: Flags.string({
+            description: "Approved template name (reaches contacts any time)",
+        }),
+        language: Flags.string({
+            char: "l",
+            description: "Template language code (e.g. en_US); required with --template",
+            dependsOn: ["template"],
+        }),
+        var: Flags.string({
+            description: "Template variable as n=value (e.g. --var 1=TinyFat). Repeatable.",
+            multiple: true,
+            dependsOn: ["template"],
+        }),
+        "idempotency-key": Flags.string({
+            description: "Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WhatsappSend);
+        if (!flags.text && !flags.template) {
+            error("Provide either --text or --template", {
+                hint: 'Free-form: --text "Hello!" · Template: --template order_shipped --language en_US',
+            });
+            this.exit(1);
+        }
+        if (flags.template && !flags.language) {
+            error("Missing --language for the template", {
+                hint: "Templates are per-language — e.g. --language en_US",
+            });
+            this.exit(1);
+        }
+        const variables = parseVariables(flags.var);
+        if (typeof variables === "string") {
+            error(variables);
+            this.exit(1);
+        }
+        const sendSpinner = spinner("Sending WhatsApp message...");
+        if (!isJsonMode()) {
+            sendSpinner.start();
+        }
+        try {
+            const response = await apiClient.post("/api/v1/messages", {
+                channel: "whatsapp",
+                to: flags.to,
+                from: flags.from,
+                ...(flags.text
+                    ? { text: flags.text }
+                    : {
+                        template: {
+                            name: flags.template,
+                            language: flags.language,
+                            ...(variables && { variables }),
+                        },
+                    }),
+            }, true, { idempotencyKey: flags["idempotency-key"] });
+            sendSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("WhatsApp message queued", {
+                "Message ID": colors.code(response.id),
+                To: response.to,
+                From: response.from,
+                Kind: response.whatsapp?.kind ?? (flags.text ? "text" : "template"),
+                ...(response.whatsapp?.template && {
+                    Template: `${response.whatsapp.template.name} (${response.whatsapp.template.language}, ${response.whatsapp.template.category})`,
+                }),
+                Status: formatStatus(response.status),
+                Credits: formatCredits(response.creditsUsed),
+            });
+        }
+        catch (err) {
+            sendSpinner.stop();
+            if (err instanceof ApiError && err.code === "whatsapp_window_closed") {
+                error(err.message, {
+                    hint: "outside the 24-hour reply window — send an approved template instead",
+                });
+                console.error(colors.dim(`  e.g. ${colors.code(`sendly whatsapp send --to ${flags.to} --from ${flags.from} --template <name> --language en_US`)}`));
+            }
+            else if (err instanceof ApiError &&
+                err.code === "whatsapp_template_not_approved") {
+                error(err.message, {
+                    hint: "Check its review status with `sendly whatsapp templates list`",
+                });
+            }
+            else if (err instanceof NotFoundError) {
+                error(err.message, {
+                    hint: "Run `sendly whatsapp templates list` to see your templates and their exact names/languages",
+                });
+            }
+            else if (err instanceof AuthenticationError &&
+                err.message?.includes("connected to WhatsApp")) {
+                error(err.message, {
+                    hint: `Connect it first: sendly whatsapp connect --number ${flags.from}`,
+                });
+            }
+            else if (err instanceof AuthenticationError &&
+                /whatsapp/i.test(err.message ?? "")) {
+                error(err.message);
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/whatsapp/send.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport {\n  apiClient,\n  ApiError,\n  AuthenticationError,\n  NotFoundError,\n} from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n  formatStatus,\n  formatCredits,\n} from \"../../lib/output.js\";\n\ninterface WhatsappSendResponse {\n  id: string;\n  channel: string;\n  message_format: string;\n  to: string;\n  from: string;\n  text: string | null;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  whatsapp: {\n    kind: string;\n    template?: { name: string; language: string; category: string };\n    messageId: string | null;\n  };\n  createdAt: string;\n  metadata: Record<string, unknown>;\n}\n\n/** Parse repeatable n=value pairs into a template-variables record. */\nfunction parseVariables(\n  raw: string[] | undefined,\n): Record<string, string> | string | undefined {\n  if (!raw || raw.length === 0) return undefined;\n  const out: Record<string, string> = {};\n  for (const item of raw) {\n    const idx = item.indexOf(\"=\");\n    if (idx <= 0) {\n      return `Invalid --var \"${item}\" — use n=value (e.g. 1=TinyFat)`;\n    }\n    out[item.slice(0, idx).trim()] = item.slice(idx + 1);\n  }\n  return out;\n}\n\nexport default class WhatsappSend extends AuthenticatedCommand {\n  static description =\n    \"Send a WhatsApp message — free-form text inside the 24-hour reply window, or an approved template any time\";\n\n  static examples = [\n    '<%= config.bin %> whatsapp send --to +15551234567 --from +15559876543 --text \"Your table is ready!\"',\n    \"<%= config.bin %> whatsapp send --to +447700900123 --from +15559876543 --template order_shipped --language en_US --var 1=TinyFat --var 2=4821\",\n    '<%= config.bin %> whatsapp send --to +15551234567 --from +15559876543 --text \"Hello!\" --json',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n      required: true,\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Your WhatsApp-connected sender number (E.164 format)\",\n      required: true,\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description:\n        \"Free-form message text (only inside the 24-hour reply window)\",\n      exclusive: [\"template\", \"language\", \"var\"],\n    }),\n    template: Flags.string({\n      description: \"Approved template name (reaches contacts any time)\",\n    }),\n    language: Flags.string({\n      char: \"l\",\n      description: \"Template language code (e.g. en_US); required with --template\",\n      dependsOn: [\"template\"],\n    }),\n    var: Flags.string({\n      description:\n        \"Template variable as n=value (e.g. --var 1=TinyFat). Repeatable.\",\n      multiple: true,\n      dependsOn: [\"template\"],\n    }),\n    \"idempotency-key\": Flags.string({\n      description:\n        \"Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(WhatsappSend);\n\n    if (!flags.text && !flags.template) {\n      error(\"Provide either --text or --template\", {\n        hint: 'Free-form: --text \"Hello!\" · Template: --template order_shipped --language en_US',\n      });\n      this.exit(1);\n    }\n    if (flags.template && !flags.language) {\n      error(\"Missing --language for the template\", {\n        hint: \"Templates are per-language — e.g. --language en_US\",\n      });\n      this.exit(1);\n    }\n\n    const variables = parseVariables(flags.var);\n    if (typeof variables === \"string\") {\n      error(variables);\n      this.exit(1);\n    }\n\n    const sendSpinner = spinner(\"Sending WhatsApp message...\");\n    if (!isJsonMode()) {\n      sendSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.post<WhatsappSendResponse>(\n        \"/api/v1/messages\",\n        {\n          channel: \"whatsapp\",\n          to: flags.to,\n          from: flags.from,\n          ...(flags.text\n            ? { text: flags.text }\n            : {\n                template: {\n                  name: flags.template,\n                  language: flags.language,\n                  ...(variables && { variables }),\n                },\n              }),\n        },\n        true,\n        { idempotencyKey: flags[\"idempotency-key\"] },\n      );\n\n      sendSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(\"WhatsApp message queued\", {\n        \"Message ID\": colors.code(response.id),\n        To: response.to,\n        From: response.from,\n        Kind: response.whatsapp?.kind ?? (flags.text ? \"text\" : \"template\"),\n        ...(response.whatsapp?.template && {\n          Template: `${response.whatsapp.template.name} (${response.whatsapp.template.language}, ${response.whatsapp.template.category})`,\n        }),\n        Status: formatStatus(response.status),\n        Credits: formatCredits(response.creditsUsed),\n      });\n    } catch (err: any) {\n      sendSpinner.stop();\n\n      if (err instanceof ApiError && err.code === \"whatsapp_window_closed\") {\n        error(err.message, {\n          hint: \"outside the 24-hour reply window — send an approved template instead\",\n        });\n        console.error(\n          colors.dim(\n            `  e.g. ${colors.code(`sendly whatsapp send --to ${flags.to} --from ${flags.from} --template <name> --language en_US`)}`,\n          ),\n        );\n      } else if (\n        err instanceof ApiError &&\n        err.code === \"whatsapp_template_not_approved\"\n      ) {\n        error(err.message, {\n          hint: \"Check its review status with `sendly whatsapp templates list`\",\n        });\n      } else if (err instanceof NotFoundError) {\n        error(err.message, {\n          hint: \"Run `sendly whatsapp templates list` to see your templates and their exact names/languages\",\n        });\n      } else if (\n        err instanceof AuthenticationError &&\n        err.message?.includes(\"connected to WhatsApp\")\n      ) {\n        error(err.message, {\n          hint: `Connect it first: sendly whatsapp connect --number ${flags.from}`,\n        });\n      } else if (\n        err instanceof AuthenticationError &&\n        /whatsapp/i.test(err.message ?? \"\")\n      ) {\n        error(err.message);\n      } else {\n        throw err;\n      }\n      this.exit(1);\n    }\n  }\n}\n"]}

package/dist/commands/whatsapp/senders.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WhatsappSenders extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/whatsapp/senders.js

@@ -0,0 +1,74 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, info, table, colors, spinner, isJsonMode, formatRelativeTime, } from "../../lib/output.js";
+function formatSenderStatus(status) {
+    switch (String(status).toLowerCase()) {
+        case "active":
+            return colors.success(status);
+        case "suspended":
+            return colors.error(status);
+        case "pending":
+            return colors.warning(status);
+        default:
+            return status;
+    }
+}
+export default class WhatsappSenders extends AuthenticatedCommand {
+    static description = "List the numbers connected to WhatsApp on your workspace";
+    static examples = [
+        "<%= config.bin %> whatsapp senders",
+        "<%= config.bin %> whatsapp senders --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(WhatsappSenders);
+        const listSpinner = spinner("Fetching WhatsApp senders...");
+        if (!isJsonMode()) {
+            listSpinner.start();
+        }
+        const response = await apiClient
+            .get("/api/v1/whatsapp/senders")
+            .finally(() => listSpinner.stop());
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const senders = response.senders ?? [];
+        if (senders.length === 0) {
+            info("No WhatsApp senders yet");
+            console.log(colors.dim(`Connect a number with: ${colors.code("sendly whatsapp connect --number +15551234567")}`));
+            return;
+        }
+        table(senders, [
+            { header: "Number", key: "phoneNumber" },
+            {
+                header: "Display name",
+                key: "displayName",
+                formatter: (v) => (v ? String(v) : colors.dim("—")),
+            },
+            {
+                header: "Status",
+                key: "status",
+                formatter: (v) => formatSenderStatus(String(v)),
+            },
+            {
+                header: "Quality",
+                key: "qualityRating",
+                formatter: (v) => (v ? String(v) : colors.dim("—")),
+            },
+            {
+                header: "Connected",
+                key: "createdAt",
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+        const pending = senders.filter((s) => String(s.status).toLowerCase() === "pending");
+        if (pending.length > 0) {
+            console.log();
+            console.log(colors.dim(`Pending senders are still connecting — someone needs to finish the Facebook sign-in. Check progress with ${colors.code("sendly whatsapp status")}.`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/whatsapp/status.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WhatsappStatus extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/whatsapp/status.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient, NotFoundError } from "../../lib/api-client.js";
+import { getConfigDir } from "../../lib/config.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../lib/output.js";
+/** Read the signup id remembered by `sendly whatsapp connect`. */
+function lastSignupId() {
+    try {
+        const raw = fs.readFileSync(path.join(getConfigDir(), "whatsapp-signup.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.id || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export default class WhatsappStatus extends AuthenticatedCommand {
+    static description = "Show the status of a WhatsApp connection (defaults to your most recent one)";
+    static examples = [
+        "<%= config.bin %> whatsapp status",
+        "<%= config.bin %> whatsapp status 3f6a1c9e-0000-0000-0000-000000000000",
+        "<%= config.bin %> whatsapp status --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Signup id (from `whatsapp connect`); omit for the latest",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WhatsappStatus);
+        const id = args.id || lastSignupId();
+        if (!id) {
+            error("No WhatsApp connection found on this machine.", {
+                hint: "Run `sendly whatsapp connect --number <phone>` first, or pass a signup id.",
+            });
+            this.exit(1);
+        }
+        const statusSpinner = spinner("Fetching WhatsApp status...");
+        if (!isJsonMode()) {
+            statusSpinner.start();
+        }
+        let response;
+        try {
+            response = await apiClient.get(`/api/v1/whatsapp/signup/${encodeURIComponent(id)}`);
+            statusSpinner.stop();
+        }
+        catch (err) {
+            statusSpinner.stop();
+            if (err instanceof NotFoundError) {
+                error("WhatsApp connection not found.", {
+                    hint: "Check the signup id, or start one with `sendly whatsapp connect`.",
+                });
+                this.exit(1);
+            }
+            throw err;
+        }
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const statusColor = response.status === "active"
+            ? colors.success
+            : response.status === "failed" || response.status === "expired"
+                ? colors.error
+                : colors.warning;
+        success("WhatsApp connection status", {
+            "Signup ID": colors.code(response.id),
+            Number: response.phoneNumber,
+            Status: statusColor(response.status),
+            "Business account": response.businessAccountId ?? colors.dim("—"),
+            ...(response.failureReasons?.length && {
+                Reasons: response.failureReasons.join("; "),
+            }),
+            Updated: new Date(response.updatedAt).toLocaleString(),
+        });
+        if (response.status === "initiated" || response.status === "registering") {
+            console.log();
+            console.log(colors.dim("Still connecting. If you closed the browser, re-run `sendly whatsapp connect` to get the link again — someone needs to open it and sign in with Facebook to finish."));
+        }
+        else if (response.status === "active") {
+            console.log();
+            console.log(colors.dim(`Send with: ${colors.code(`sendly whatsapp send --from ${response.phoneNumber} --to +15551230000 --text "Hello!"`)}`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../src/commands/whatsapp/status.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { Args } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient, NotFoundError } from \"../../lib/api-client.js\";\nimport { getConfigDir } from \"../../lib/config.js\";\nimport {\n  success,\n  error,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface SignupStatusResponse {\n  id: string;\n  status: string;\n  phoneNumber: string;\n  businessAccountId: string | null;\n  failureReasons: string[] | null;\n  updatedAt: string;\n}\n\n/** Read the signup id remembered by `sendly whatsapp connect`. */\nfunction lastSignupId(): string | undefined {\n  try {\n    const raw = fs.readFileSync(\n      path.join(getConfigDir(), \"whatsapp-signup.json\"),\n      \"utf8\",\n    );\n    const parsed = JSON.parse(raw) as { id?: string };\n    return parsed.id || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport default class WhatsappStatus extends AuthenticatedCommand {\n  static description =\n    \"Show the status of a WhatsApp connection (defaults to your most recent one)\";\n\n  static examples = [\n    \"<%= config.bin %> whatsapp status\",\n    \"<%= config.bin %> whatsapp status 3f6a1c9e-0000-0000-0000-000000000000\",\n    \"<%= config.bin %> whatsapp status --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Signup id (from `whatsapp connect`); omit for the latest\",\n      required: false,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n  };\n\n  async run(): Promise<void> {\n    const { args } = await this.parse(WhatsappStatus);\n\n    const id = args.id || lastSignupId();\n    if (!id) {\n      error(\"No WhatsApp connection found on this machine.\", {\n        hint: \"Run `sendly whatsapp connect --number <phone>` first, or pass a signup id.\",\n      });\n      this.exit(1);\n    }\n\n    const statusSpinner = spinner(\"Fetching WhatsApp status...\");\n    if (!isJsonMode()) {\n      statusSpinner.start();\n    }\n\n    let response: SignupStatusResponse;\n    try {\n      response = await apiClient.get<SignupStatusResponse>(\n        `/api/v1/whatsapp/signup/${encodeURIComponent(id!)}`,\n      );\n      statusSpinner.stop();\n    } catch (err: any) {\n      statusSpinner.stop();\n      if (err instanceof NotFoundError) {\n        error(\"WhatsApp connection not found.\", {\n          hint: \"Check the signup id, or start one with `sendly whatsapp connect`.\",\n        });\n        this.exit(1);\n      }\n      throw err;\n    }\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    const statusColor =\n      response.status === \"active\"\n        ? colors.success\n        : response.status === \"failed\" || response.status === \"expired\"\n          ? colors.error\n          : colors.warning;\n\n    success(\"WhatsApp connection status\", {\n      \"Signup ID\": colors.code(response.id),\n      Number: response.phoneNumber,\n      Status: statusColor(response.status),\n      \"Business account\": response.businessAccountId ?? colors.dim(\"—\"),\n      ...(response.failureReasons?.length && {\n        Reasons: response.failureReasons.join(\"; \"),\n      }),\n      Updated: new Date(response.updatedAt).toLocaleString(),\n    });\n\n    if (response.status === \"initiated\" || response.status === \"registering\") {\n      console.log();\n      console.log(\n        colors.dim(\n          \"Still connecting. If you closed the browser, re-run `sendly whatsapp connect` to get the link again — someone needs to open it and sign in with Facebook to finish.\",\n        ),\n      );\n    } else if (response.status === \"active\") {\n      console.log();\n      console.log(\n        colors.dim(\n          `Send with: ${colors.code(`sendly whatsapp send --from ${response.phoneNumber} --to +15551230000 --text \"Hello!\"`)}`,\n        ),\n      );\n    }\n  }\n}\n"]}

package/dist/commands/whatsapp/templates/create.d.ts

@@ -0,0 +1,19 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WhatsappTemplatesCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        sender: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        language: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        body: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        footer: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        header: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        button: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        example: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}