@sendly/cli 3.36.0 → 3.37.0

package/dist/commands/10dlc/campaigns/assign.js

@@ -0,0 +1,64 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, success, colors, isJsonMode, keyValue, } from "../../../lib/output.js";
+function formatAssignmentStatus(status) {
+    switch (status) {
+        case "Active":
+            return colors.success(status);
+        case "Under review":
+            return colors.warning(status);
+        case "Action needed":
+            return colors.error(status);
+        default:
+            return status;
+    }
+}
+export default class TendlcCampaignsAssign extends AuthenticatedCommand {
+    static description = "Assign a phone number you own to an active campaign, making it sendable";
+    static examples = [
+        '<%= config.bin %> 10dlc campaigns assign cmp_xxx --number "+15551234567"',
+        '<%= config.bin %> 10dlc campaigns assign cmp_xxx --number "+15551234567" --json',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        number: Flags.string({
+            char: "n",
+            description: "Phone number to assign (E.164, must be on your account)",
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TendlcCampaignsAssign);
+        const response = await apiClient.post(`/api/v1/tendlc/campaigns/${args.id}/assign`, { phoneNumber: flags.number });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const assignment = response.data;
+        success(`Number assigned: ${assignment.phoneNumber}`);
+        console.log();
+        keyValue([
+            ["Assignment", assignment.id],
+            ["Campaign", assignment.campaignId],
+            ["Status", formatAssignmentStatus(assignment.status)],
+            ...(assignment.assignedAt
+                ? [
+                    [
+                        "Assigned",
+                        new Date(assignment.assignedAt).toLocaleString(),
+                    ],
+                ]
+                : []),
+        ]);
+        console.log();
+        console.log(colors.dim(`Send from it with: sendly sms send --to "+15559876543" --text "Hi!" --from "${assignment.phoneNumber}"`));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/10dlc/campaigns/create.d.ts

@@ -0,0 +1,24 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class TendlcCampaignsCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        brand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "use-case": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "message-flow": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        sample: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "sub-use-case": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "opt-in-keywords": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "opt-out-keywords": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "help-keywords": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "opt-in-message": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "opt-out-message": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "help-message": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "embedded-link": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "embedded-phone": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        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/10dlc/campaigns/create.js

@@ -0,0 +1,118 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, success, colors, isJsonMode, keyValue, } from "../../../lib/output.js";
+const TEXT_FIELDS = {
+    "opt-in-keywords": "optInKeywords",
+    "opt-out-keywords": "optOutKeywords",
+    "help-keywords": "helpKeywords",
+    "opt-in-message": "optInMessage",
+    "opt-out-message": "optOutMessage",
+    "help-message": "helpMessage",
+};
+export default class TendlcCampaignsCreate extends AuthenticatedCommand {
+    static description = "Create a messaging campaign under a verified brand and submit it for carrier review";
+    static examples = [
+        '<%= config.bin %> 10dlc campaigns create --brand brd_xxx --use-case MIXED --description "Order updates and promotions" --message-flow "Customers opt in at checkout" --sample "Your order has shipped!" --sample "20% off this weekend"',
+        '<%= config.bin %> 10dlc campaigns create --brand brd_xxx --use-case 2FA --description "Login codes" --message-flow "Users request a code at sign-in" --sample "Your code is {{code}}" --opt-out-keywords "STOP,UNSUBSCRIBE"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        brand: Flags.string({
+            char: "b",
+            description: "Brand ID (must be verified)",
+            required: true,
+        }),
+        "use-case": Flags.string({
+            description: "Use-case code (e.g. MIXED, MARKETING, ACCOUNT_NOTIFICATION, 2FA)",
+            required: true,
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "What this campaign sends",
+            required: true,
+        }),
+        "message-flow": Flags.string({
+            description: "How recipients opt in to receive messages",
+            required: true,
+        }),
+        sample: Flags.string({
+            char: "s",
+            description: "Sample message (repeat for up to 5 samples)",
+            multiple: true,
+            required: true,
+        }),
+        "sub-use-case": Flags.string({
+            description: "Sub use-case code (can specify multiple)",
+            multiple: true,
+        }),
+        "opt-in-keywords": Flags.string({
+            description: "Comma-separated opt-in keywords",
+        }),
+        "opt-out-keywords": Flags.string({
+            description: "Comma-separated opt-out keywords",
+        }),
+        "help-keywords": Flags.string({
+            description: "Comma-separated help keywords",
+        }),
+        "opt-in-message": Flags.string({
+            description: "Reply sent on opt-in",
+        }),
+        "opt-out-message": Flags.string({
+            description: "Reply sent on opt-out",
+        }),
+        "help-message": Flags.string({
+            description: "Reply sent on a help keyword",
+        }),
+        "embedded-link": Flags.boolean({
+            description: "Messages include links (default true; disable with --no-embedded-link)",
+            allowNo: true,
+        }),
+        "embedded-phone": Flags.boolean({
+            description: "Messages include phone numbers (default false)",
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TendlcCampaignsCreate);
+        const body = {
+            brandId: flags.brand,
+            useCase: flags["use-case"],
+            description: flags.description,
+            messageFlow: flags["message-flow"],
+            sampleMessages: flags.sample,
+        };
+        if (flags["sub-use-case"] && flags["sub-use-case"].length > 0) {
+            body.subUseCases = flags["sub-use-case"];
+        }
+        for (const [flagKey, wireKey] of Object.entries(TEXT_FIELDS)) {
+            const v = flags[flagKey];
+            if (typeof v === "string" && v.length > 0)
+                body[wireKey] = v;
+        }
+        if (flags["embedded-link"] !== undefined) {
+            body.embeddedLink = flags["embedded-link"];
+        }
+        if (flags["embedded-phone"] !== undefined) {
+            body.embeddedPhone = flags["embedded-phone"];
+        }
+        const response = await apiClient.post("/api/v1/tendlc/campaigns", body);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const campaign = response.data;
+        success(`Campaign submitted for carrier review: ${campaign.id}`);
+        console.log();
+        keyValue([
+            ["Brand", campaign.brandId],
+            ["Use case", campaign.useCase],
+            ["Status", colors.warning(campaign.status)],
+        ]);
+        console.log();
+        console.log(colors.dim("Next steps:"));
+        console.log(`  Check status: ${colors.code(`sendly 10dlc campaigns get ${campaign.id}`)}`);
+        console.log(`  Once active:  ${colors.code(`sendly 10dlc campaigns assign ${campaign.id} --number "+15551234567"`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../../src/commands/10dlc/campaigns/create.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  json,\n  success,\n  colors,\n  isJsonMode,\n  keyValue,\n} from \"../../../lib/output.js\";\n\ninterface Campaign {\n  id: string;\n  brandId: string;\n  useCase: string;\n  status: string;\n  createdAt: string;\n}\n\ninterface CreateCampaignResponse {\n  data: Campaign;\n}\n\nconst TEXT_FIELDS: Record<string, string> = {\n  \"opt-in-keywords\": \"optInKeywords\",\n  \"opt-out-keywords\": \"optOutKeywords\",\n  \"help-keywords\": \"helpKeywords\",\n  \"opt-in-message\": \"optInMessage\",\n  \"opt-out-message\": \"optOutMessage\",\n  \"help-message\": \"helpMessage\",\n};\n\nexport default class TendlcCampaignsCreate extends AuthenticatedCommand {\n  static description =\n    \"Create a messaging campaign under a verified brand and submit it for carrier review\";\n\n  static examples = [\n    '<%= config.bin %> 10dlc campaigns create --brand brd_xxx --use-case MIXED --description \"Order updates and promotions\" --message-flow \"Customers opt in at checkout\" --sample \"Your order has shipped!\" --sample \"20% off this weekend\"',\n    '<%= config.bin %> 10dlc campaigns create --brand brd_xxx --use-case 2FA --description \"Login codes\" --message-flow \"Users request a code at sign-in\" --sample \"Your code is {{code}}\" --opt-out-keywords \"STOP,UNSUBSCRIBE\"',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    brand: Flags.string({\n      char: \"b\",\n      description: \"Brand ID (must be verified)\",\n      required: true,\n    }),\n    \"use-case\": Flags.string({\n      description: \"Use-case code (e.g. MIXED, MARKETING, ACCOUNT_NOTIFICATION, 2FA)\",\n      required: true,\n    }),\n    description: Flags.string({\n      char: \"d\",\n      description: \"What this campaign sends\",\n      required: true,\n    }),\n    \"message-flow\": Flags.string({\n      description: \"How recipients opt in to receive messages\",\n      required: true,\n    }),\n    sample: Flags.string({\n      char: \"s\",\n      description: \"Sample message (repeat for up to 5 samples)\",\n      multiple: true,\n      required: true,\n    }),\n    \"sub-use-case\": Flags.string({\n      description: \"Sub use-case code (can specify multiple)\",\n      multiple: true,\n    }),\n    \"opt-in-keywords\": Flags.string({\n      description: \"Comma-separated opt-in keywords\",\n    }),\n    \"opt-out-keywords\": Flags.string({\n      description: \"Comma-separated opt-out keywords\",\n    }),\n    \"help-keywords\": Flags.string({\n      description: \"Comma-separated help keywords\",\n    }),\n    \"opt-in-message\": Flags.string({\n      description: \"Reply sent on opt-in\",\n    }),\n    \"opt-out-message\": Flags.string({\n      description: \"Reply sent on opt-out\",\n    }),\n    \"help-message\": Flags.string({\n      description: \"Reply sent on a help keyword\",\n    }),\n    \"embedded-link\": Flags.boolean({\n      description: \"Messages include links (default true; disable with --no-embedded-link)\",\n      allowNo: true,\n    }),\n    \"embedded-phone\": Flags.boolean({\n      description: \"Messages include phone numbers (default false)\",\n      allowNo: true,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(TendlcCampaignsCreate);\n\n    const body: Record<string, unknown> = {\n      brandId: flags.brand,\n      useCase: flags[\"use-case\"],\n      description: flags.description,\n      messageFlow: flags[\"message-flow\"],\n      sampleMessages: flags.sample,\n    };\n\n    if (flags[\"sub-use-case\"] && flags[\"sub-use-case\"].length > 0) {\n      body.subUseCases = flags[\"sub-use-case\"];\n    }\n    for (const [flagKey, wireKey] of Object.entries(TEXT_FIELDS)) {\n      const v = flags[flagKey as keyof typeof flags];\n      if (typeof v === \"string\" && v.length > 0) body[wireKey] = v;\n    }\n    if (flags[\"embedded-link\"] !== undefined) {\n      body.embeddedLink = flags[\"embedded-link\"];\n    }\n    if (flags[\"embedded-phone\"] !== undefined) {\n      body.embeddedPhone = flags[\"embedded-phone\"];\n    }\n\n    const response = await apiClient.post<CreateCampaignResponse>(\n      \"/api/v1/tendlc/campaigns\",\n      body,\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    const campaign = response.data;\n\n    success(`Campaign submitted for carrier review: ${campaign.id}`);\n    console.log();\n\n    keyValue([\n      [\"Brand\", campaign.brandId],\n      [\"Use case\", campaign.useCase],\n      [\"Status\", colors.warning(campaign.status)],\n    ]);\n\n    console.log();\n    console.log(colors.dim(\"Next steps:\"));\n    console.log(\n      `  Check status: ${colors.code(`sendly 10dlc campaigns get ${campaign.id}`)}`,\n    );\n    console.log(\n      `  Once active:  ${colors.code(`sendly 10dlc campaigns assign ${campaign.id} --number \"+15551234567\"`)}`,\n    );\n  }\n}\n"]}

package/dist/commands/10dlc/campaigns/get.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class TendlcCampaignsGet 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/10dlc/campaigns/get.js

@@ -0,0 +1,84 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, colors, formatStatus, isJsonMode, keyValue, } from "../../../lib/output.js";
+function formatCampaignStatus(status) {
+    switch (status) {
+        case "suspended":
+            return colors.warning(status);
+        case "expired":
+            return colors.dim(status);
+        default:
+            return formatStatus(status);
+    }
+}
+export default class TendlcCampaignsGet extends AuthenticatedCommand {
+    static description = "Get campaign details with the latest carrier-review status (run again to refresh)";
+    static examples = [
+        "<%= config.bin %> 10dlc campaigns get cmp_xxx",
+        "<%= config.bin %> 10dlc campaigns get cmp_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(TendlcCampaignsGet);
+        const response = await apiClient.get(`/api/v1/tendlc/campaigns/${args.id}`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const campaign = response.data;
+        console.log();
+        console.log(colors.bold(`Campaign: ${campaign.useCase}`));
+        console.log();
+        keyValue([
+            ["ID", campaign.id],
+            ["Brand", campaign.brandId],
+            ["Status", formatCampaignStatus(campaign.status)],
+            ...(campaign.subUseCases.length > 0
+                ? [["Sub use cases", campaign.subUseCases.join(", ")]]
+                : []),
+            ...(campaign.throughput
+                ? [
+                    ["Throughput tier", campaign.throughput.tier],
+                    [
+                        "Carriers ready",
+                        String(campaign.throughput.carriersReady),
+                    ],
+                ]
+                : []),
+            ["Created", new Date(campaign.createdAt).toLocaleString()],
+            ["Updated", new Date(campaign.updatedAt).toLocaleString()],
+        ]);
+        if (campaign.description) {
+            console.log();
+            console.log(colors.dim("Description:"));
+            console.log(`  ${campaign.description}`);
+        }
+        if (campaign.sampleMessages.length > 0) {
+            console.log();
+            console.log(colors.dim("Sample messages:"));
+            campaign.sampleMessages.forEach((m) => console.log(`  - ${m}`));
+        }
+        if (campaign.failureReasons && campaign.failureReasons.length > 0) {
+            console.log();
+            console.log(colors.error("Failure reasons:"));
+            campaign.failureReasons.forEach((r) => console.log(`  - ${r}`));
+        }
+        console.log();
+        if (campaign.status === "pending") {
+            console.log(colors.dim("Carrier review is in progress — run this command again to refresh."));
+        }
+        else if (campaign.status === "active") {
+            console.log(colors.dim(`Assign a number with: sendly 10dlc campaigns assign ${campaign.id} --number "+15551234567"`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../../src/commands/10dlc/campaigns/get.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../../lib/base-command.js\";\nimport { apiClient } from \"../../../lib/api-client.js\";\nimport {\n  json,\n  colors,\n  formatStatus,\n  isJsonMode,\n  keyValue,\n} from \"../../../lib/output.js\";\n\ninterface Campaign {\n  id: string;\n  brandId: string;\n  useCase: string;\n  subUseCases: string[];\n  description: string | null;\n  status: string;\n  sampleMessages: string[];\n  throughput: {\n    tier: string;\n    carriersReady: number;\n  } | null;\n  failureReasons: string[] | null;\n  createdAt: string;\n  updatedAt: string;\n}\n\ninterface GetCampaignResponse {\n  data: Campaign;\n}\n\nfunction formatCampaignStatus(status: string): string {\n  switch (status) {\n    case \"suspended\":\n      return colors.warning(status);\n    case \"expired\":\n      return colors.dim(status);\n    default:\n      return formatStatus(status);\n  }\n}\n\nexport default class TendlcCampaignsGet extends AuthenticatedCommand {\n  static description =\n    \"Get campaign details with the latest carrier-review status (run again to refresh)\";\n\n  static examples = [\n    \"<%= config.bin %> 10dlc campaigns get cmp_xxx\",\n    \"<%= config.bin %> 10dlc campaigns get cmp_xxx --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Campaign ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n  };\n\n  async run(): Promise<void> {\n    const { args } = await this.parse(TendlcCampaignsGet);\n\n    const response = await apiClient.get<GetCampaignResponse>(\n      `/api/v1/tendlc/campaigns/${args.id}`,\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    const campaign = response.data;\n\n    console.log();\n    console.log(colors.bold(`Campaign: ${campaign.useCase}`));\n    console.log();\n\n    keyValue([\n      [\"ID\", campaign.id],\n      [\"Brand\", campaign.brandId],\n      [\"Status\", formatCampaignStatus(campaign.status)],\n      ...(campaign.subUseCases.length > 0\n        ? [[\"Sub use cases\", campaign.subUseCases.join(\", \")] as [string, string]]\n        : []),\n      ...(campaign.throughput\n        ? [\n            [\"Throughput tier\", campaign.throughput.tier] as [string, string],\n            [\n              \"Carriers ready\",\n              String(campaign.throughput.carriersReady),\n            ] as [string, string],\n          ]\n        : []),\n      [\"Created\", new Date(campaign.createdAt).toLocaleString()],\n      [\"Updated\", new Date(campaign.updatedAt).toLocaleString()],\n    ]);\n\n    if (campaign.description) {\n      console.log();\n      console.log(colors.dim(\"Description:\"));\n      console.log(`  ${campaign.description}`);\n    }\n\n    if (campaign.sampleMessages.length > 0) {\n      console.log();\n      console.log(colors.dim(\"Sample messages:\"));\n      campaign.sampleMessages.forEach((m) => console.log(`  - ${m}`));\n    }\n\n    if (campaign.failureReasons && campaign.failureReasons.length > 0) {\n      console.log();\n      console.log(colors.error(\"Failure reasons:\"));\n      campaign.failureReasons.forEach((r) => console.log(`  - ${r}`));\n    }\n\n    console.log();\n    if (campaign.status === \"pending\") {\n      console.log(\n        colors.dim(\n          \"Carrier review is in progress — run this command again to refresh.\",\n        ),\n      );\n    } else if (campaign.status === \"active\") {\n      console.log(\n        colors.dim(\n          `Assign a number with: sendly 10dlc campaigns assign ${campaign.id} --number \"+15551234567\"`,\n        ),\n      );\n    }\n  }\n}\n"]}

package/dist/commands/10dlc/campaigns/list.d.ts

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

@@ -0,0 +1,70 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { table, json, info, formatStatus, formatRelativeTime, colors, isJsonMode, } from "../../../lib/output.js";
+function formatCampaignStatus(status) {
+    switch (status) {
+        case "suspended":
+            return colors.warning(status);
+        case "expired":
+            return colors.dim(status);
+        default:
+            return formatStatus(status);
+    }
+}
+export default class TendlcCampaignsList extends AuthenticatedCommand {
+    static description = "List the messaging campaigns registered for carrier review";
+    static examples = [
+        "<%= config.bin %> 10dlc campaigns list",
+        "<%= config.bin %> 10dlc campaigns list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(TendlcCampaignsList);
+        const response = await apiClient.get("/api/v1/tendlc/campaigns");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (!response.data || response.data.length === 0) {
+            info("No campaigns yet. Create one with: sendly 10dlc campaigns create --brand <brandId> ...");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.data.length} campaigns`));
+        console.log();
+        table(response.data, [
+            {
+                header: "ID",
+                key: "id",
+                width: 38,
+                formatter: (v) => colors.dim(String(v)),
+            },
+            {
+                header: "Use case",
+                key: "useCase",
+                width: 22,
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 11,
+                formatter: (v) => formatCampaignStatus(String(v)),
+            },
+            {
+                header: "Throughput",
+                key: "throughput",
+                width: 13,
+                formatter: (v) => v ? v.tier : "-",
+            },
+            {
+                header: "Created",
+                key: "createdAt",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/10dlc/qualify.d.ts

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

@@ -0,0 +1,56 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, success, warn, colors, isJsonMode, keyValue, } from "../../lib/output.js";
+export default class TendlcQualify extends AuthenticatedCommand {
+    static description = "Check whether a use case qualifies for a brand on the carrier network before creating a campaign";
+    static examples = [
+        "<%= config.bin %> 10dlc qualify brd_xxx MIXED",
+        "<%= config.bin %> 10dlc qualify brd_xxx MARKETING --json",
+    ];
+    static args = {
+        brand: Args.string({
+            description: "Brand ID",
+            required: true,
+        }),
+        usecase: Args.string({
+            description: "Use-case code (e.g. MIXED, MARKETING, ACCOUNT_NOTIFICATION, 2FA)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(TendlcQualify);
+        const response = await apiClient.get(`/api/v1/tendlc/brands/${args.brand}/qualify/${encodeURIComponent(args.usecase)}`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const result = response.data;
+        if (result.qualified) {
+            success(`${result.useCase} qualifies for this brand`);
+            if (result.throughput) {
+                console.log();
+                keyValue([
+                    ["Throughput tier", result.throughput.tier],
+                    ["Carriers ready", String(result.throughput.carriersReady)],
+                ]);
+            }
+            console.log();
+            console.log(colors.dim(`Create a campaign with: sendly 10dlc campaigns create --brand ${args.brand} --use-case ${result.useCase} ...`));
+        }
+        else {
+            warn(`${result.useCase} does not qualify for this brand`);
+            if (result.reason) {
+                console.log(`  ${colors.dim("reason:")} ${result.reason}`);
+            }
+            console.log();
+            console.log(colors.dim("Try another use case, e.g.: sendly 10dlc qualify " +
+                args.brand +
+                " MIXED"));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/keys/rotate.js

@@ -20,7 +20,7 @@ export default class KeysRotate extends AuthenticatedCommand {
         ...AuthenticatedCommand.baseFlags,
         "grace-period": Flags.integer({
             char: "g",
-            description: "Hours to keep old key active (0 = immediate revocation)",
+            description: "Hours to keep the old key active during rotation (24-168, default 24)",
         }),
         yes: Flags.boolean({
             char: "y",
@@ -51,24 +51,19 @@ export default class KeysRotate extends AuthenticatedCommand {
             }
             const response = await apiClient.post(`/api/v1/account/keys/${args.keyId}/rotate`, body);
             if (isJsonMode()) {
-                json({
-                    success: true,
-                    newKeyId: response.newKey.id,
-                    key: response.key,
-                    oldKeyExpiresAt: response.oldKeyExpiresAt,
-                });
+                json(response);
                 return;
             }
             success("API key rotated", {
                 "New Key ID": response.newKey.id,
-                "New Key": colors.highlight(response.key),
+                "New Key": colors.highlight(response.newKey.key),
                 Name: response.newKey.name,
-                ...(response.oldKeyExpiresAt && {
-                    "Old Key Expires": new Date(response.oldKeyExpiresAt).toLocaleString(),
+                ...(response.oldKey?.expiresAt && {
+                    "Old Key Expires": new Date(response.oldKey.expiresAt).toLocaleString(),
                 }),
             });
             this.log("");
-            this.log(colors.warning("Save this key - it won't be shown again!"));
+            this.log(colors.warning(response.newKey.warning || "Save this key - it won't be shown again!"));
         }
         catch (err) {
             if (err.message?.includes("not_found") || err.message?.includes("404")) {
@@ -79,4 +74,4 @@ export default class KeysRotate extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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