@sendly/cli 3.17.0 → 3.18.2

package/dist/commands/credits/balance.js

@@ -29,11 +29,11 @@ export default class CreditsBalance extends AuthenticatedCommand {
         });
         console.log();
         // Show approximate message capacity
-        const domesticMessages = Math.floor(availableCredits / 1);
+        const domesticMessages = Math.floor(availableCredits / 2);
         const internationalMessages = Math.floor(availableCredits / 2);
         console.log(colors.dim("Estimated capacity:"));
         console.log(`  ${colors.dim("US/Canada:")} ~${domesticMessages.toLocaleString()} messages`);
         console.log(`  ${colors.dim("International:")} ~${internationalMessages.toLocaleString()} messages`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFsYW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9jcmVkaXRzL2JhbGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFFTCxJQUFJLEVBQ0osUUFBUSxFQUNSLE1BQU0sRUFDTixNQUFNLEVBQ04sVUFBVSxHQUNYLE1BQU0scUJBQXFCLENBQUM7QUFlN0IsTUFBTSxDQUFDLE9BQU8sT0FBTyxjQUFlLFNBQVEsb0JBQW9CO0lBQzlELE1BQU0sQ0FBQyxXQUFXLEdBQUcsMkJBQTJCLENBQUM7SUFFakQsTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQixtQ0FBbUM7UUFDbkMsMENBQTBDO0tBQzNDLENBQUM7SUFFRixNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTO0tBQ2xDLENBQUM7SUFFRixLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sT0FBTyxHQUFHLE1BQU0sU0FBUyxDQUFDLEdBQUcsQ0FDakMseUJBQXlCLENBQzFCLENBQUM7UUFFRixJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBQ2QsT0FBTztRQUNULENBQUM7UUFFRCxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUV6QixNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDO1FBQ2hDLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxlQUFlLENBQUM7UUFDekMsTUFBTSxnQkFBZ0IsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUM7UUFFbEQsUUFBUSxDQUFDO1lBQ1AsU0FBUyxFQUFFLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQyxjQUFjLEVBQUUsVUFBVSxDQUFDO1lBQ3pFLFFBQVEsRUFDTixRQUFRLEdBQUcsQ0FBQztnQkFDVixDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLFFBQVEsQ0FBQyxjQUFjLEVBQUUsVUFBVSxDQUFDO2dCQUN4RCxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUM7WUFDN0IsZUFBZSxFQUFFLEdBQUcsT0FBTyxDQUFDLGNBQWMsRUFBRSxVQUFVO1NBQ3ZELENBQUMsQ0FBQztRQUVILE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUVkLG9DQUFvQztRQUNwQyxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDMUQsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixHQUFHLENBQUMsQ0FBQyxDQUFDO1FBRS9ELE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDLENBQUM7UUFDL0MsT0FBTyxDQUFDLEdBQUcsQ0FDVCxLQUFLLE1BQU0sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLEtBQUssZ0JBQWdCLENBQUMsY0FBYyxFQUFFLFdBQVcsQ0FDL0UsQ0FBQztRQUNGLE9BQU8sQ0FBQyxHQUFHLENBQ1QsS0FBSyxNQUFNLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLEtBQUsscUJBQXFCLENBQUMsY0FBYyxFQUFFLFdBQVcsQ0FDeEYsQ0FBQztJQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBdXRoZW50aWNhdGVkQ29tbWFuZCB9IGZyb20gXCIuLi8uLi9saWIvYmFzZS1jb21tYW5kLmpzXCI7XG5pbXBvcnQgeyBhcGlDbGllbnQgfSBmcm9tIFwiLi4vLi4vbGliL2FwaS1jbGllbnQuanNcIjtcbmltcG9ydCB7XG4gIHN1Y2Nlc3MsXG4gIGpzb24sXG4gIGtleVZhbHVlLFxuICBjb2xvcnMsXG4gIGhlYWRlcixcbiAgaXNKc29uTW9kZSxcbn0gZnJvbSBcIi4uLy4uL2xpYi9vdXRwdXQuanNcIjtcblxuaW50ZXJmYWNlIENyZWRpdHNSZXNwb25zZSB7XG4gIGJhbGFuY2U6IG51bWJlcjtcbiAgcmVzZXJ2ZWRCYWxhbmNlOiBudW1iZXI7XG4gIGF2YWlsYWJsZUJhbGFuY2U6IG51bWJlcjtcbiAgcmVjZW50VHJhbnNhY3Rpb25zPzogQXJyYXk8e1xuICAgIGlkOiBzdHJpbmc7XG4gICAgYW1vdW50OiBudW1iZXI7XG4gICAgdHlwZTogc3RyaW5nO1xuICAgIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gICAgY3JlYXRlZEF0OiBzdHJpbmc7XG4gIH0+O1xufVxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBDcmVkaXRzQmFsYW5jZSBleHRlbmRzIEF1dGhlbnRpY2F0ZWRDb21tYW5kIHtcbiAgc3RhdGljIGRlc2NyaXB0aW9uID0gXCJDaGVjayB5b3VyIGNyZWRpdCBiYWxhbmNlXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gY3JlZGl0cyBiYWxhbmNlXCIsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiBjcmVkaXRzIGJhbGFuY2UgLS1qc29uXCIsXG4gIF07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkF1dGhlbnRpY2F0ZWRDb21tYW5kLmJhc2VGbGFncyxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgY3JlZGl0cyA9IGF3YWl0IGFwaUNsaWVudC5nZXQ8Q3JlZGl0c1Jlc3BvbnNlPihcbiAgICAgIFwiL2FwaS92MS9hY2NvdW50L2NyZWRpdHNcIixcbiAgICApO1xuXG4gICAgaWYgKGlzSnNvbk1vZGUoKSkge1xuICAgICAganNvbihjcmVkaXRzKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBoZWFkZXIoXCJDcmVkaXQgQmFsYW5jZVwiKTtcblxuICAgIGNvbnN0IGJhbGFuY2UgPSBjcmVkaXRzLmJhbGFuY2U7XG4gICAgY29uc3QgcmVzZXJ2ZWQgPSBjcmVkaXRzLnJlc2VydmVkQmFsYW5jZTtcbiAgICBjb25zdCBhdmFpbGFibGVDcmVkaXRzID0gY3JlZGl0cy5hdmFpbGFibGVCYWxhbmNlO1xuXG4gICAga2V5VmFsdWUoe1xuICAgICAgQXZhaWxhYmxlOiBjb2xvcnMucHJpbWFyeShgJHthdmFpbGFibGVDcmVkaXRzLnRvTG9jYWxlU3RyaW5nKCl9IGNyZWRpdHNgKSxcbiAgICAgIFJlc2VydmVkOlxuICAgICAgICByZXNlcnZlZCA+IDBcbiAgICAgICAgICA/IGNvbG9ycy53YXJuaW5nKGAke3Jlc2VydmVkLnRvTG9jYWxlU3RyaW5nKCl9IGNyZWRpdHNgKVxuICAgICAgICAgIDogY29sb3JzLmRpbShcIjAgY3JlZGl0c1wiKSxcbiAgICAgIFwiVG90YWwgQmFsYW5jZVwiOiBgJHtiYWxhbmNlLnRvTG9jYWxlU3RyaW5nKCl9IGNyZWRpdHNgLFxuICAgIH0pO1xuXG4gICAgY29uc29sZS5sb2coKTtcblxuICAgIC8vIFNob3cgYXBwcm94aW1hdGUgbWVzc2FnZSBjYXBhY2l0eVxuICAgIGNvbnN0IGRvbWVzdGljTWVzc2FnZXMgPSBNYXRoLmZsb29yKGF2YWlsYWJsZUNyZWRpdHMgLyAyKTtcbiAgICBjb25zdCBpbnRlcm5hdGlvbmFsTWVzc2FnZXMgPSBNYXRoLmZsb29yKGF2YWlsYWJsZUNyZWRpdHMgLyAyKTtcblxuICAgIGNvbnNvbGUubG9nKGNvbG9ycy5kaW0oXCJFc3RpbWF0ZWQgY2FwYWNpdHk6XCIpKTtcbiAgICBjb25zb2xlLmxvZyhcbiAgICAgIGAgICR7Y29sb3JzLmRpbShcIlVTL0NhbmFkYTpcIil9IH4ke2RvbWVzdGljTWVzc2FnZXMudG9Mb2NhbGVTdHJpbmcoKX0gbWVzc2FnZXNgLFxuICAgICk7XG4gICAgY29uc29sZS5sb2coXG4gICAgICBgICAke2NvbG9ycy5kaW0oXCJJbnRlcm5hdGlvbmFsOlwiKX0gfiR7aW50ZXJuYXRpb25hbE1lc3NhZ2VzLnRvTG9jYWxlU3RyaW5nKCl9IG1lc3NhZ2VzYCxcbiAgICApO1xuICB9XG59XG4iXX0=

package/dist/commands/enterprise/analytics/credits.d.ts

@@ -0,0 +1,11 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class AnalyticsCredits extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        period: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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/enterprise/analytics/credits.js

@@ -0,0 +1,59 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, formatCredits, } from "../../../lib/output.js";
+export default class AnalyticsCredits extends AuthenticatedCommand {
+    static description = "Get credit usage analytics over time";
+    static examples = [
+        "<%= config.bin %> enterprise analytics credits",
+        "<%= config.bin %> enterprise analytics credits --period 30d",
+        "<%= config.bin %> enterprise analytics credits --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        period: Flags.string({
+            char: "p",
+            description: "Time period (7d, 30d, 90d)",
+            options: ["7d", "30d", "90d"],
+            default: "7d",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsCredits);
+        const response = await apiClient.get("/api/v1/enterprise/analytics/credits", { period: flags.period });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header(`Credit Usage (${flags.period})`);
+        console.log();
+        console.log(`  ${colors.dim("Total Used:")} ${formatCredits(response.totals.totalUsed)}  ` +
+            `${colors.dim("Allocated:")} ${formatCredits(response.totals.totalAllocated)}  ` +
+            `${colors.dim("Balance:")} ${colors.primary(formatCredits(response.totals.currentBalance))}`);
+        console.log();
+        table(response.data, [
+            { header: "Date", key: "date", width: 12 },
+            {
+                header: "Used",
+                key: "used",
+                width: 12,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Allocated",
+                key: "allocated",
+                width: 12,
+                formatter: (v) => Number(v) > 0
+                    ? colors.success(`+${Number(v).toLocaleString()}`)
+                    : colors.dim("0"),
+            },
+            {
+                header: "Balance",
+                key: "balance",
+                width: 12,
+                formatter: (v) => colors.primary(Number(v).toLocaleString()),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/analytics/delivery.d.ts

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

@@ -0,0 +1,60 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class AnalyticsDelivery extends AuthenticatedCommand {
+    static description = "Get delivery rate analytics by workspace";
+    static examples = [
+        "<%= config.bin %> enterprise analytics delivery",
+        "<%= config.bin %> enterprise analytics delivery --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const response = await apiClient.get("/api/v1/enterprise/analytics/delivery");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header("Delivery Rates by Workspace");
+        console.log();
+        table(response.workspaces, [
+            { header: "Workspace", key: "workspaceName", width: 24 },
+            {
+                header: "Sent",
+                key: "sent",
+                width: 10,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Delivered",
+                key: "delivered",
+                width: 10,
+                formatter: (v) => colors.success(Number(v).toLocaleString()),
+            },
+            {
+                header: "Failed",
+                key: "failed",
+                width: 10,
+                formatter: (v) => Number(v) > 0
+                    ? colors.error(Number(v).toLocaleString())
+                    : colors.dim("0"),
+            },
+            {
+                header: "Rate",
+                key: "deliveryRate",
+                width: 8,
+                formatter: (v) => {
+                    const rate = Number(v);
+                    const text = `${rate.toFixed(1)}%`;
+                    return rate >= 95
+                        ? colors.success(text)
+                        : rate >= 80
+                            ? colors.warning(text)
+                            : colors.error(text);
+                },
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/analytics/messages.d.ts

@@ -0,0 +1,11 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class AnalyticsMessages extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        period: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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/enterprise/analytics/messages.js

@@ -0,0 +1,59 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class AnalyticsMessages extends AuthenticatedCommand {
+    static description = "Get message analytics across all workspaces";
+    static examples = [
+        "<%= config.bin %> enterprise analytics messages",
+        "<%= config.bin %> enterprise analytics messages --period 30d",
+        "<%= config.bin %> enterprise analytics messages --period 90d --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        period: Flags.string({
+            char: "p",
+            description: "Time period (7d, 30d, 90d)",
+            options: ["7d", "30d", "90d"],
+            default: "7d",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsMessages);
+        const response = await apiClient.get("/api/v1/enterprise/analytics/messages", { period: flags.period });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header(`Message Analytics (${flags.period})`);
+        console.log();
+        console.log(`  ${colors.dim("Totals:")} ${response.totals.sent.toLocaleString()} sent, ` +
+            `${colors.success(response.totals.delivered.toLocaleString() + " delivered")}, ` +
+            `${response.totals.failed > 0 ? colors.error(response.totals.failed.toLocaleString() + " failed") : colors.dim("0 failed")}`);
+        console.log();
+        table(response.data, [
+            { header: "Date", key: "date", width: 12 },
+            {
+                header: "Sent",
+                key: "sent",
+                width: 10,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Delivered",
+                key: "delivered",
+                width: 10,
+                formatter: (v) => colors.success(Number(v).toLocaleString()),
+            },
+            {
+                header: "Failed",
+                key: "failed",
+                width: 10,
+                formatter: (v) => Number(v) > 0
+                    ? colors.error(Number(v).toLocaleString())
+                    : colors.dim("0"),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/analytics/overview.d.ts

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

@@ -0,0 +1,42 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatCredits, } from "../../../lib/output.js";
+export default class AnalyticsOverview extends AuthenticatedCommand {
+    static description = "Get enterprise-wide analytics overview";
+    static examples = [
+        "<%= config.bin %> enterprise analytics overview",
+        "<%= config.bin %> enterprise analytics overview --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const overview = await apiClient.get("/api/v1/enterprise/analytics/overview");
+        if (isJsonMode()) {
+            json(overview);
+            return;
+        }
+        header("Enterprise Overview");
+        keyValue({
+            "Total Workspaces": String(overview.totalWorkspaces),
+            Active: colors.success(String(overview.activeWorkspaces)),
+            Suspended: overview.suspendedWorkspaces > 0
+                ? colors.error(String(overview.suspendedWorkspaces))
+                : colors.dim("0"),
+        });
+        console.log();
+        header("Messaging");
+        keyValue({
+            "Messages Sent": overview.totalMessagesSent.toLocaleString(),
+            "Messages Delivered": overview.totalMessagesDelivered.toLocaleString(),
+            "Delivery Rate": `${overview.deliveryRate.toFixed(1)}%`,
+        });
+        console.log();
+        header("Credits");
+        keyValue({
+            "Credits Used": formatCredits(overview.totalCreditsUsed),
+            "Credits Remaining": colors.primary(formatCredits(overview.totalCreditsRemaining)),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/billing.d.ts

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

@@ -0,0 +1,70 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, } from "../../lib/output.js";
+export default class EnterpriseBilling extends AuthenticatedCommand {
+    static description = "Get billing breakdown by workspace";
+    static examples = [
+        "<%= config.bin %> enterprise billing",
+        "<%= config.bin %> enterprise billing --page 2",
+        "<%= config.bin %> enterprise billing --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        page: Flags.integer({
+            description: "Page number",
+            default: 1,
+        }),
+        limit: Flags.integer({
+            description: "Results per page",
+            default: 20,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseBilling);
+        const response = await apiClient.get("/api/v1/enterprise/billing/workspace-breakdown", { page: flags.page, limit: flags.limit });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header("Billing Breakdown");
+        console.log();
+        console.log(`  ${colors.dim("Platform Fee:")}  $${response.platformFee.toFixed(2)}/mo`);
+        console.log(`  ${colors.dim("Seat Fees:")}     $${response.totalSeatFees.toFixed(2)}/mo`);
+        console.log(`  ${colors.dim("Credits:")}       $${response.totalCreditsPurchased.toFixed(2)}`);
+        console.log(`  ${colors.bold("Total:")}         ${colors.primary("$" + response.totalAmount.toFixed(2))}`);
+        console.log();
+        table(response.workspaces, [
+            { header: "Workspace", key: "workspaceName", width: 24 },
+            {
+                header: "Seat Fee",
+                key: "seatFee",
+                width: 10,
+                formatter: (v) => `$${Number(v).toFixed(2)}`,
+            },
+            {
+                header: "Credits Bought",
+                key: "creditsPurchased",
+                width: 14,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Credits Used",
+                key: "creditsUsed",
+                width: 12,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Messages",
+                key: "messagesCount",
+                width: 10,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+        ]);
+        if (response.totalPages > 1) {
+            console.log();
+            console.log(colors.dim(`  Page ${response.page} of ${response.totalPages}. Use --page to navigate.`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/credits.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseCredits extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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/enterprise/credits.js

@@ -0,0 +1,37 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatCredits, } from "../../lib/output.js";
+export default class EnterpriseCredits extends AuthenticatedCommand {
+    static description = "Check credit balance for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise credits org_abc123",
+        "<%= config.bin %> enterprise credits org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(EnterpriseCredits);
+        const credits = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}/credits`);
+        if (isJsonMode()) {
+            json(credits);
+            return;
+        }
+        header("Workspace Credits");
+        keyValue({
+            Available: colors.primary(formatCredits(credits.availableBalance)),
+            Reserved: credits.reservedBalance > 0
+                ? colors.warning(formatCredits(credits.reservedBalance))
+                : colors.dim("0 credits"),
+            "Total Balance": formatCredits(credits.balance),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/keys/create.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseKeysCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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/enterprise/keys/create.js

@@ -0,0 +1,53 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, warn, json, colors, codeBlock, isJsonMode, } from "../../../lib/output.js";
+export default class EnterpriseKeysCreate extends AuthenticatedCommand {
+    static description = "Create an API key for an enterprise workspace";
+    static examples = [
+        '<%= config.bin %> enterprise keys create org_abc123 --name "Production"',
+        '<%= config.bin %> enterprise keys create org_abc123 --name "CI" --type test',
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Name for the API key",
+            required: true,
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Key type (test or live)",
+            options: ["test", "live"],
+            default: "live",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnterpriseKeysCreate);
+        const response = await apiClient.post(`/api/v1/enterprise/workspaces/${args.workspaceId}/keys`, {
+            name: flags.name,
+            type: flags.type,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("API key created", {
+            Name: response.name,
+            "Key ID": response.id,
+            Type: flags.type === "test"
+                ? colors.warning("test")
+                : colors.success("live"),
+        });
+        console.log();
+        warn("Copy your API key now. You won't be able to see it again!");
+        codeBlock(response.key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/enterprise/keys/list.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseKeysList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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>;
+}