@sendly/cli 3.20.0 → 3.24.0

package/dist/commands/conversations/close.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsClose extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, 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/conversations/close.js

@@ -0,0 +1,43 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, spinner, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsClose extends AuthenticatedCommand {
+    static description = "Close a conversation";
+    static examples = [
+        "<%= config.bin %> conversations close conv_abc123",
+        "<%= config.bin %> conversations close conv_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConversationsClose);
+        const spin = spinner("Closing conversation...");
+        spin.start();
+        try {
+            const response = await apiClient.post(`/api/v1/conversations/${encodeURIComponent(args.id)}/close`);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Conversation closed", {
+                ID: response.id,
+                "Phone Number": response.phoneNumber,
+                Status: response.status,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/conversations/get.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        messages: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, 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>;
+}

package/dist/commands/conversations/get.js

@@ -0,0 +1,87 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { keyValue, json, header, formatStatus, formatDate, formatPhone, formatRelativeTime, colors, divider, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsGet extends AuthenticatedCommand {
+    static description = "Get details of a conversation";
+    static examples = [
+        "<%= config.bin %> conversations get conv_abc123",
+        "<%= config.bin %> conversations get conv_abc123 --messages",
+        "<%= config.bin %> conversations get conv_abc123 --messages --limit 10",
+        "<%= config.bin %> conversations get conv_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        messages: Flags.boolean({
+            char: "m",
+            description: "Include message thread",
+            default: false,
+        }),
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of messages to include (requires --messages)",
+            default: 50,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConversationsGet);
+        const conversation = await apiClient.get(`/api/v1/conversations/${encodeURIComponent(args.id)}`, {
+            ...(flags.messages && { include_messages: "true" }),
+            ...(flags.messages && { message_limit: flags.limit }),
+        });
+        if (isJsonMode()) {
+            json(conversation);
+            return;
+        }
+        header("Conversation Details");
+        keyValue({
+            ID: conversation.id,
+            "Phone Number": formatPhone(conversation.phoneNumber),
+            Status: formatStatus(conversation.status),
+            Messages: conversation.messageCount,
+            Unread: conversation.unreadCount > 0
+                ? colors.warning(String(conversation.unreadCount))
+                : "0",
+            "Last Message": conversation.lastMessageAt
+                ? formatRelativeTime(conversation.lastMessageAt)
+                : colors.dim("None"),
+            ...(conversation.lastMessageDirection && {
+                Direction: conversation.lastMessageDirection,
+            }),
+            ...(conversation.tags && conversation.tags.length > 0 && {
+                Tags: conversation.tags.join(", "),
+            }),
+            Created: formatDate(conversation.createdAt),
+        });
+        if (flags.messages && conversation.messages) {
+            divider();
+            console.log(colors.bold("Message Thread:"));
+            console.log(colors.dim("─".repeat(40)));
+            if (conversation.messages.data.length === 0) {
+                console.log(colors.dim("  No messages"));
+            }
+            else {
+                for (const msg of conversation.messages.data) {
+                    const direction = msg.direction === "inbound"
+                        ? colors.info("←")
+                        : colors.success("→");
+                    const time = formatRelativeTime(msg.createdAt);
+                    const text = msg.text || colors.dim("(no text)");
+                    console.log(`  ${direction} ${colors.dim(time)}  ${text}`);
+                }
+                if (conversation.messages.pagination.hasMore) {
+                    console.log();
+                    console.log(colors.dim(`  ${conversation.messages.pagination.total - conversation.messages.data.length} more messages...`));
+                }
+            }
+            console.log();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/commands/conversations/get.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  keyValue,\n  json,\n  header,\n  formatStatus,\n  formatDate,\n  formatPhone,\n  formatRelativeTime,\n  colors,\n  divider,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface ConversationMessage {\n  id: string;\n  to: string;\n  from: string;\n  text: string;\n  status: string;\n  direction: string;\n  createdAt: string;\n}\n\ninterface ConversationResponse {\n  id: string;\n  phoneNumber: string;\n  status: string;\n  messageCount: number;\n  unreadCount: number;\n  lastMessageText?: string;\n  lastMessageAt?: string;\n  lastMessageDirection?: string;\n  metadata?: Record<string, unknown>;\n  tags?: string[];\n  createdAt: string;\n  messages?: {\n    data: ConversationMessage[];\n    pagination: { total: number; limit: number; offset: number; hasMore: boolean };\n  };\n}\n\nexport default class ConversationsGet extends AuthenticatedCommand {\n  static description = \"Get details of a conversation\";\n\n  static examples = [\n    \"<%= config.bin %> conversations get conv_abc123\",\n    \"<%= config.bin %> conversations get conv_abc123 --messages\",\n    \"<%= config.bin %> conversations get conv_abc123 --messages --limit 10\",\n    \"<%= config.bin %> conversations get conv_abc123 --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Conversation ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    messages: Flags.boolean({\n      char: \"m\",\n      description: \"Include message thread\",\n      default: false,\n    }),\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of messages to include (requires --messages)\",\n      default: 50,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(ConversationsGet);\n\n    const conversation = await apiClient.get<ConversationResponse>(\n      `/api/v1/conversations/${encodeURIComponent(args.id)}`,\n      {\n        ...(flags.messages && { include_messages: \"true\" }),\n        ...(flags.messages && { message_limit: flags.limit }),\n      },\n    );\n\n    if (isJsonMode()) {\n      json(conversation);\n      return;\n    }\n\n    header(\"Conversation Details\");\n\n    keyValue({\n      ID: conversation.id,\n      \"Phone Number\": formatPhone(conversation.phoneNumber),\n      Status: formatStatus(conversation.status),\n      Messages: conversation.messageCount,\n      Unread: conversation.unreadCount > 0\n        ? colors.warning(String(conversation.unreadCount))\n        : \"0\",\n      \"Last Message\": conversation.lastMessageAt\n        ? formatRelativeTime(conversation.lastMessageAt)\n        : colors.dim(\"None\"),\n      ...(conversation.lastMessageDirection && {\n        Direction: conversation.lastMessageDirection,\n      }),\n      ...(conversation.tags && conversation.tags.length > 0 && {\n        Tags: conversation.tags.join(\", \"),\n      }),\n      Created: formatDate(conversation.createdAt),\n    });\n\n    if (flags.messages && conversation.messages) {\n      divider();\n      console.log(colors.bold(\"Message Thread:\"));\n      console.log(colors.dim(\"─\".repeat(40)));\n\n      if (conversation.messages.data.length === 0) {\n        console.log(colors.dim(\"  No messages\"));\n      } else {\n        for (const msg of conversation.messages.data) {\n          const direction = msg.direction === \"inbound\"\n            ? colors.info(\"←\")\n            : colors.success(\"→\");\n          const time = formatRelativeTime(msg.createdAt);\n          const text = msg.text || colors.dim(\"(no text)\");\n          console.log(`  ${direction} ${colors.dim(time)}  ${text}`);\n        }\n\n        if (conversation.messages.pagination.hasMore) {\n          console.log();\n          console.log(\n            colors.dim(`  ${conversation.messages.pagination.total - conversation.messages.data.length} more messages...`),\n          );\n        }\n      }\n      console.log();\n    }\n  }\n}\n"]}

package/dist/commands/conversations/index.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class Conversations 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/conversations/index.js

@@ -0,0 +1,79 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, formatStatus, formatRelativeTime, formatPhone, colors, isJsonMode, } from "../../lib/output.js";
+export default class Conversations extends AuthenticatedCommand {
+    static description = "List conversations (default subcommand)";
+    static examples = [
+        "<%= config.bin %> conversations",
+        "<%= config.bin %> conversations --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(Conversations);
+        const response = await apiClient.get("/api/v1/conversations", { limit: 20 });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.data.length === 0) {
+            info("No conversations found");
+            return;
+        }
+        const pagination = response.pagination;
+        console.log();
+        console.log(colors.dim(`Showing ${response.data.length} conversations (${pagination.total} total)`));
+        console.log();
+        table(response.data, [
+            {
+                header: "Phone Number",
+                key: "phoneNumber",
+                width: 16,
+                formatter: (v) => formatPhone(String(v)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 10,
+                formatter: (v) => formatStatus(String(v)),
+            },
+            {
+                header: "Messages",
+                key: "messageCount",
+                width: 10,
+            },
+            {
+                header: "Unread",
+                key: "unreadCount",
+                width: 8,
+                formatter: (v) => {
+                    const count = Number(v);
+                    return count > 0 ? colors.warning(String(count)) : String(count);
+                },
+            },
+            {
+                header: "Last Message",
+                key: "lastMessageText",
+                width: 25,
+                formatter: (v) => {
+                    if (!v)
+                        return colors.dim("-");
+                    const text = String(v);
+                    return text.length > 22 ? text.slice(0, 22) + "..." : text;
+                },
+            },
+            {
+                header: "Last Activity",
+                key: "lastMessageAt",
+                width: 14,
+                formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim("-")),
+            },
+        ]);
+        if (pagination.hasMore) {
+            console.log();
+            console.log(colors.dim(`  Use ${colors.code("conversations list --offset 20")} to see more`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/conversations/list.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        offset: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        status: 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>;
+}

package/dist/commands/conversations/list.js

@@ -0,0 +1,99 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, formatStatus, formatRelativeTime, formatPhone, colors, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsList extends AuthenticatedCommand {
+    static description = "List conversations";
+    static examples = [
+        "<%= config.bin %> conversations list",
+        "<%= config.bin %> conversations list --status active",
+        "<%= config.bin %> conversations list --limit 10",
+        "<%= config.bin %> conversations list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of conversations per page",
+            default: 20,
+        }),
+        offset: Flags.integer({
+            description: "Offset from start",
+        }),
+        status: Flags.string({
+            char: "s",
+            description: "Filter by status (active, closed)",
+            options: ["active", "closed"],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ConversationsList);
+        const response = await apiClient.get("/api/v1/conversations", {
+            limit: flags.limit,
+            ...(flags.offset != null && { offset: flags.offset }),
+            ...(flags.status && { status: flags.status }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.data.length === 0) {
+            info("No conversations found");
+            return;
+        }
+        const pagination = response.pagination;
+        console.log();
+        console.log(colors.dim(`Showing ${response.data.length} conversations (${pagination.total} total)`));
+        console.log();
+        table(response.data, [
+            {
+                header: "Phone Number",
+                key: "phoneNumber",
+                width: 16,
+                formatter: (v) => formatPhone(String(v)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 10,
+                formatter: (v) => formatStatus(String(v)),
+            },
+            {
+                header: "Messages",
+                key: "messageCount",
+                width: 10,
+            },
+            {
+                header: "Unread",
+                key: "unreadCount",
+                width: 8,
+                formatter: (v) => {
+                    const count = Number(v);
+                    return count > 0 ? colors.warning(String(count)) : String(count);
+                },
+            },
+            {
+                header: "Last Message",
+                key: "lastMessageText",
+                width: 25,
+                formatter: (v) => {
+                    if (!v)
+                        return colors.dim("-");
+                    const text = String(v);
+                    return text.length > 22 ? text.slice(0, 22) + "..." : text;
+                },
+            },
+            {
+                header: "Last Activity",
+                key: "lastMessageAt",
+                width: 14,
+                formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim("-")),
+            },
+        ]);
+        if (pagination.hasMore) {
+            console.log();
+            console.log(colors.dim(`  Use ${colors.code(`--offset ${(flags.offset || 0) + flags.limit}`)} to see more`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../src/commands/conversations/list.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  table,\n  json,\n  info,\n  formatStatus,\n  formatRelativeTime,\n  formatPhone,\n  colors,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface Conversation {\n  id: string;\n  phoneNumber: string;\n  status: string;\n  messageCount: number;\n  unreadCount: number;\n  lastMessageText?: string;\n  lastMessageAt?: string;\n}\n\ninterface Pagination {\n  total: number;\n  limit: number;\n  offset: number;\n  hasMore: boolean;\n}\n\ninterface ListConversationsResponse {\n  data: Conversation[];\n  pagination: Pagination;\n}\n\nexport default class ConversationsList extends AuthenticatedCommand {\n  static description = \"List conversations\";\n\n  static examples = [\n    \"<%= config.bin %> conversations list\",\n    \"<%= config.bin %> conversations list --status active\",\n    \"<%= config.bin %> conversations list --limit 10\",\n    \"<%= config.bin %> conversations list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of conversations per page\",\n      default: 20,\n    }),\n    offset: Flags.integer({\n      description: \"Offset from start\",\n    }),\n    status: Flags.string({\n      char: \"s\",\n      description: \"Filter by status (active, closed)\",\n      options: [\"active\", \"closed\"],\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(ConversationsList);\n\n    const response = await apiClient.get<ListConversationsResponse>(\n      \"/api/v1/conversations\",\n      {\n        limit: flags.limit,\n        ...(flags.offset != null && { offset: flags.offset }),\n        ...(flags.status && { status: flags.status }),\n      },\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    if (response.data.length === 0) {\n      info(\"No conversations found\");\n      return;\n    }\n\n    const pagination = response.pagination;\n\n    console.log();\n    console.log(\n      colors.dim(\n        `Showing ${response.data.length} conversations (${pagination.total} total)`,\n      ),\n    );\n    console.log();\n\n    table(response.data, [\n      {\n        header: \"Phone Number\",\n        key: \"phoneNumber\",\n        width: 16,\n        formatter: (v) => formatPhone(String(v)),\n      },\n      {\n        header: \"Status\",\n        key: \"status\",\n        width: 10,\n        formatter: (v) => formatStatus(String(v)),\n      },\n      {\n        header: \"Messages\",\n        key: \"messageCount\",\n        width: 10,\n      },\n      {\n        header: \"Unread\",\n        key: \"unreadCount\",\n        width: 8,\n        formatter: (v) => {\n          const count = Number(v);\n          return count > 0 ? colors.warning(String(count)) : String(count);\n        },\n      },\n      {\n        header: \"Last Message\",\n        key: \"lastMessageText\",\n        width: 25,\n        formatter: (v) => {\n          if (!v) return colors.dim(\"-\");\n          const text = String(v);\n          return text.length > 22 ? text.slice(0, 22) + \"...\" : text;\n        },\n      },\n      {\n        header: \"Last Activity\",\n        key: \"lastMessageAt\",\n        width: 14,\n        formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim(\"-\")),\n      },\n    ]);\n\n    if (pagination.hasMore) {\n      console.log();\n      console.log(\n        colors.dim(\n          `  Use ${colors.code(`--offset ${(flags.offset || 0) + flags.limit}`)} to see more`,\n        ),\n      );\n    }\n  }\n}\n"]}

package/dist/commands/conversations/mark-read.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsMarkRead extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, 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/conversations/mark-read.js

@@ -0,0 +1,42 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, spinner, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsMarkRead extends AuthenticatedCommand {
+    static description = "Mark a conversation as read";
+    static examples = [
+        "<%= config.bin %> conversations mark-read conv_abc123",
+        "<%= config.bin %> conversations mark-read conv_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConversationsMarkRead);
+        const spin = spinner("Marking conversation as read...");
+        spin.start();
+        try {
+            const response = await apiClient.post(`/api/v1/conversations/${encodeURIComponent(args.id)}/mark-read`);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Conversation marked as read", {
+                ID: response.id,
+                "Phone Number": response.phoneNumber,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/conversations/reopen.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsReopen extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, 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/conversations/reopen.js

@@ -0,0 +1,43 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, spinner, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsReopen extends AuthenticatedCommand {
+    static description = "Reopen a closed conversation";
+    static examples = [
+        "<%= config.bin %> conversations reopen conv_abc123",
+        "<%= config.bin %> conversations reopen conv_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConversationsReopen);
+        const spin = spinner("Reopening conversation...");
+        spin.start();
+        try {
+            const response = await apiClient.post(`/api/v1/conversations/${encodeURIComponent(args.id)}/reopen`);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Conversation reopened", {
+                ID: response.id,
+                "Phone Number": response.phoneNumber,
+                Status: response.status,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/conversations/reply.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsReply extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        text: import("@oclif/core/lib/interfaces/parser.js").Arg<string, 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/conversations/reply.js

@@ -0,0 +1,47 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, spinner, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsReply extends AuthenticatedCommand {
+    static description = "Send a reply in a conversation";
+    static examples = [
+        '<%= config.bin %> conversations reply conv_abc123 "Thanks for reaching out!"',
+        '<%= config.bin %> conversations reply conv_abc123 "Got it" --json',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+        text: Args.string({
+            description: "Reply message text",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConversationsReply);
+        const spin = spinner("Sending reply...");
+        spin.start();
+        try {
+            const response = await apiClient.post(`/api/v1/conversations/${encodeURIComponent(args.id)}/messages`, { text: args.text });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Reply sent", {
+                ID: response.id,
+                To: response.to,
+                Status: response.status,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/drafts/approve.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class DraftsApprove extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, 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>;
+}