@sendly/cli 3.24.0 → 3.27.1

package/dist/commands/enterprise/generate-business-page.js

@@ -0,0 +1,62 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, isJsonMode, spinner, } from "../../lib/output.js";
+export default class EnterpriseGenerateBusinessPage extends AuthenticatedCommand {
+    static description = "Generate a hosted business page for verification";
+    static examples = [
+        '<%= config.bin %> enterprise generate-business-page --name "Acme Services" --use-case "Appointment Reminders"',
+        '<%= config.bin %> enterprise generate-business-page --name "Acme Services" --email hello@acme.com --phone +15551234567',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Business name (required)",
+            required: true,
+        }),
+        "use-case": Flags.string({
+            description: "Use case (e.g. Appointment Reminders)",
+        }),
+        summary: Flags.string({
+            description: "Use case summary",
+        }),
+        email: Flags.string({
+            description: "Contact email",
+        }),
+        phone: Flags.string({
+            description: "Contact phone",
+        }),
+        address: Flags.string({
+            description: "Business address",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseGenerateBusinessPage);
+        const spin = spinner("Generating business page...");
+        spin.start();
+        const body = { businessName: flags.name };
+        if (flags["use-case"])
+            body.useCase = flags["use-case"];
+        if (flags.summary)
+            body.useCaseSummary = flags.summary;
+        if (flags.email)
+            body.contactEmail = flags.email;
+        if (flags.phone)
+            body.contactPhone = flags.phone;
+        if (flags.address)
+            body.businessAddress = flags.address;
+        const response = await apiClient.post("/api/v1/enterprise/business-page/generate", body);
+        spin.succeed("Business page generated");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Business page generated", {
+            URL: colors.success(response.url),
+            Slug: response.slug,
+            "Page ID": colors.dim(response.pageId),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGUtYnVzaW5lc3MtcGFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9lbnRlcnByaXNlL2dlbmVyYXRlLWJ1c2luZXNzLXBhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNwQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDcEQsT0FBTyxFQUNMLE9BQU8sRUFDUCxJQUFJLEVBQ0osTUFBTSxFQUNOLFVBQVUsRUFDVixPQUFPLEdBQ1IsTUFBTSxxQkFBcUIsQ0FBQztBQVE3QixNQUFNLENBQUMsT0FBTyxPQUFPLDhCQUErQixTQUFRLG9CQUFvQjtJQUM5RSxNQUFNLENBQUMsV0FBVyxHQUFHLGtEQUFrRCxDQUFDO0lBRXhFLE1BQU0sQ0FBQyxRQUFRLEdBQUc7UUFDaEIsK0dBQStHO1FBQy9HLHdIQUF3SDtLQUN6SCxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssR0FBRztRQUNiLEdBQUcsb0JBQW9CLENBQUMsU0FBUztRQUNqQyxJQUFJLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUNqQixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSwwQkFBMEI7WUFDdkMsUUFBUSxFQUFFLElBQUk7U0FDZixDQUFDO1FBQ0YsVUFBVSxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDdkIsV0FBVyxFQUFFLHVDQUF1QztTQUNyRCxDQUFDO1FBQ0YsT0FBTyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDcEIsV0FBVyxFQUFFLGtCQUFrQjtTQUNoQyxDQUFDO1FBQ0YsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDbEIsV0FBVyxFQUFFLGVBQWU7U0FDN0IsQ0FBQztRQUNGLEtBQUssRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQ2xCLFdBQVcsRUFBRSxlQUFlO1NBQzdCLENBQUM7UUFDRixPQUFPLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUNwQixXQUFXLEVBQUUsa0JBQWtCO1NBQ2hDLENBQUM7S0FDSCxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLDhCQUE4QixDQUFDLENBQUM7UUFFbkUsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLDZCQUE2QixDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBRWIsTUFBTSxJQUFJLEdBQTRCLEVBQUUsWUFBWSxFQUFFLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNuRSxJQUFJLEtBQUssQ0FBQyxVQUFVLENBQUM7WUFBRSxJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUN4RCxJQUFJLEtBQUssQ0FBQyxPQUFPO1lBQUUsSUFBSSxDQUFDLGNBQWMsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDO1FBQ3ZELElBQUksS0FBSyxDQUFDLEtBQUs7WUFBRSxJQUFJLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUM7UUFDakQsSUFBSSxLQUFLLENBQUMsS0FBSztZQUFFLElBQUksQ0FBQyxZQUFZLEdBQUcsS0FBSyxDQUFDLEtBQUssQ0FBQztRQUNqRCxJQUFJLEtBQUssQ0FBQyxPQUFPO1lBQUUsSUFBSSxDQUFDLGVBQWUsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDO1FBRXhELE1BQU0sUUFBUSxHQUFHLE1BQU0sU0FBUyxDQUFDLElBQUksQ0FDbkMsMkNBQTJDLEVBQzNDLElBQUksQ0FDTCxDQUFDO1FBRUYsSUFBSSxDQUFDLE9BQU8sQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO1FBRXhDLElBQUksVUFBVSxFQUFFLEVBQUUsQ0FBQztZQUNqQixJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDZixPQUFPO1FBQ1QsQ0FBQztRQUVELE9BQU8sQ0FBQyx5QkFBeUIsRUFBRTtZQUNqQyxHQUFHLEVBQUUsTUFBTSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDO1lBQ2pDLElBQUksRUFBRSxRQUFRLENBQUMsSUFBSTtZQUNuQixTQUFTLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDO1NBQ3ZDLENBQUMsQ0FBQztJQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGbGFncyB9IGZyb20gXCJAb2NsaWYvY29yZVwiO1xuaW1wb3J0IHsgQXV0aGVudGljYXRlZENvbW1hbmQgfSBmcm9tIFwiLi4vLi4vbGliL2Jhc2UtY29tbWFuZC5qc1wiO1xuaW1wb3J0IHsgYXBpQ2xpZW50IH0gZnJvbSBcIi4uLy4uL2xpYi9hcGktY2xpZW50LmpzXCI7XG5pbXBvcnQge1xuICBzdWNjZXNzLFxuICBqc29uLFxuICBjb2xvcnMsXG4gIGlzSnNvbk1vZGUsXG4gIHNwaW5uZXIsXG59IGZyb20gXCIuLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5cbmludGVyZmFjZSBHZW5lcmF0ZUJ1c2luZXNzUGFnZVJlc3BvbnNlIHtcbiAgc2x1Zzogc3RyaW5nO1xuICB1cmw6IHN0cmluZztcbiAgcGFnZUlkOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEVudGVycHJpc2VHZW5lcmF0ZUJ1c2luZXNzUGFnZSBleHRlbmRzIEF1dGhlbnRpY2F0ZWRDb21tYW5kIHtcbiAgc3RhdGljIGRlc2NyaXB0aW9uID0gXCJHZW5lcmF0ZSBhIGhvc3RlZCBidXNpbmVzcyBwYWdlIGZvciB2ZXJpZmljYXRpb25cIjtcblxuICBzdGF0aWMgZXhhbXBsZXMgPSBbXG4gICAgJzwlPSBjb25maWcuYmluICU+IGVudGVycHJpc2UgZ2VuZXJhdGUtYnVzaW5lc3MtcGFnZSAtLW5hbWUgXCJBY21lIFNlcnZpY2VzXCIgLS11c2UtY2FzZSBcIkFwcG9pbnRtZW50IFJlbWluZGVyc1wiJyxcbiAgICAnPCU9IGNvbmZpZy5iaW4gJT4gZW50ZXJwcmlzZSBnZW5lcmF0ZS1idXNpbmVzcy1wYWdlIC0tbmFtZSBcIkFjbWUgU2VydmljZXNcIiAtLWVtYWlsIGhlbGxvQGFjbWUuY29tIC0tcGhvbmUgKzE1NTUxMjM0NTY3JyxcbiAgXTtcblxuICBzdGF0aWMgZmxhZ3MgPSB7XG4gICAgLi4uQXV0aGVudGljYXRlZENvbW1hbmQuYmFzZUZsYWdzLFxuICAgIG5hbWU6IEZsYWdzLnN0cmluZyh7XG4gICAgICBjaGFyOiBcIm5cIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIkJ1c2luZXNzIG5hbWUgKHJlcXVpcmVkKVwiLFxuICAgICAgcmVxdWlyZWQ6IHRydWUsXG4gICAgfSksXG4gICAgXCJ1c2UtY2FzZVwiOiBGbGFncy5zdHJpbmcoe1xuICAgICAgZGVzY3JpcHRpb246IFwiVXNlIGNhc2UgKGUuZy4gQXBwb2ludG1lbnQgUmVtaW5kZXJzKVwiLFxuICAgIH0pLFxuICAgIHN1bW1hcnk6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJVc2UgY2FzZSBzdW1tYXJ5XCIsXG4gICAgfSksXG4gICAgZW1haWw6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJDb250YWN0IGVtYWlsXCIsXG4gICAgfSksXG4gICAgcGhvbmU6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJDb250YWN0IHBob25lXCIsXG4gICAgfSksXG4gICAgYWRkcmVzczogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIkJ1c2luZXNzIGFkZHJlc3NcIixcbiAgICB9KSxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgeyBmbGFncyB9ID0gYXdhaXQgdGhpcy5wYXJzZShFbnRlcnByaXNlR2VuZXJhdGVCdXNpbmVzc1BhZ2UpO1xuXG4gICAgY29uc3Qgc3BpbiA9IHNwaW5uZXIoXCJHZW5lcmF0aW5nIGJ1c2luZXNzIHBhZ2UuLi5cIik7XG4gICAgc3Bpbi5zdGFydCgpO1xuXG4gICAgY29uc3QgYm9keTogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gPSB7IGJ1c2luZXNzTmFtZTogZmxhZ3MubmFtZSB9O1xuICAgIGlmIChmbGFnc1tcInVzZS1jYXNlXCJdKSBib2R5LnVzZUNhc2UgPSBmbGFnc1tcInVzZS1jYXNlXCJdO1xuICAgIGlmIChmbGFncy5zdW1tYXJ5KSBib2R5LnVzZUNhc2VTdW1tYXJ5ID0gZmxhZ3Muc3VtbWFyeTtcbiAgICBpZiAoZmxhZ3MuZW1haWwpIGJvZHkuY29udGFjdEVtYWlsID0gZmxhZ3MuZW1haWw7XG4gICAgaWYgKGZsYWdzLnBob25lKSBib2R5LmNvbnRhY3RQaG9uZSA9IGZsYWdzLnBob25lO1xuICAgIGlmIChmbGFncy5hZGRyZXNzKSBib2R5LmJ1c2luZXNzQWRkcmVzcyA9IGZsYWdzLmFkZHJlc3M7XG5cbiAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGFwaUNsaWVudC5wb3N0PEdlbmVyYXRlQnVzaW5lc3NQYWdlUmVzcG9uc2U+KFxuICAgICAgXCIvYXBpL3YxL2VudGVycHJpc2UvYnVzaW5lc3MtcGFnZS9nZW5lcmF0ZVwiLFxuICAgICAgYm9keSxcbiAgICApO1xuXG4gICAgc3Bpbi5zdWNjZWVkKFwiQnVzaW5lc3MgcGFnZSBnZW5lcmF0ZWRcIik7XG5cbiAgICBpZiAoaXNKc29uTW9kZSgpKSB7XG4gICAgICBqc29uKHJlc3BvbnNlKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBzdWNjZXNzKFwiQnVzaW5lc3MgcGFnZSBnZW5lcmF0ZWRcIiwge1xuICAgICAgVVJMOiBjb2xvcnMuc3VjY2VzcyhyZXNwb25zZS51cmwpLFxuICAgICAgU2x1ZzogcmVzcG9uc2Uuc2x1ZyxcbiAgICAgIFwiUGFnZSBJRFwiOiBjb2xvcnMuZGltKHJlc3BvbnNlLnBhZ2VJZCksXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/dist/commands/enterprise/upload-verification-document.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseUploadVerificationDocument extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "workspace-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "verification-id": 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/enterprise/upload-verification-document.js

@@ -0,0 +1,109 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { success, json, isJsonMode, spinner } from "../../lib/output.js";
+import { getAuthToken, getConfigValue, getEffectiveValue, } from "../../lib/config.js";
+import { ApiError, AuthenticationError, } from "../../lib/api-client.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export default class EnterpriseUploadVerificationDocument extends AuthenticatedCommand {
+    static description = "Upload a verification document (image or PDF)";
+    static examples = [
+        '<%= config.bin %> enterprise upload-verification-document --file ./ein-letter.png',
+        '<%= config.bin %> enterprise upload-verification-document --file ./doc.pdf --workspace-id ws_123',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        file: Flags.string({
+            char: "f",
+            description: "Path to the file to upload (image or PDF)",
+            required: true,
+        }),
+        "workspace-id": Flags.string({
+            description: "Workspace ID to associate the document with",
+        }),
+        "verification-id": Flags.string({
+            description: "Verification ID to associate the document with",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseUploadVerificationDocument);
+        const filePath = flags.file;
+        if (!fs.existsSync(filePath)) {
+            this.error(`File not found: ${filePath}`);
+        }
+        const filename = path.basename(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        let mimetype = "application/octet-stream";
+        if (ext === ".jpg" || ext === ".jpeg")
+            mimetype = "image/jpeg";
+        else if (ext === ".png")
+            mimetype = "image/png";
+        else if (ext === ".gif")
+            mimetype = "image/gif";
+        else if (ext === ".pdf")
+            mimetype = "application/pdf";
+        else if (ext === ".webp")
+            mimetype = "image/webp";
+        const fileBuffer = fs.readFileSync(filePath);
+        const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).substring(2)}`;
+        const parts = [];
+        parts.push(Buffer.from(`--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="file"; filename="${filename}"\r\n` +
+            `Content-Type: ${mimetype}\r\n\r\n`));
+        parts.push(fileBuffer);
+        if (flags["workspace-id"]) {
+            parts.push(Buffer.from(`\r\n--${boundary}\r\n` +
+                `Content-Disposition: form-data; name="workspaceId"\r\n\r\n` +
+                flags["workspace-id"]));
+        }
+        if (flags["verification-id"]) {
+            parts.push(Buffer.from(`\r\n--${boundary}\r\n` +
+                `Content-Disposition: form-data; name="verificationId"\r\n\r\n` +
+                flags["verification-id"]));
+        }
+        parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        const token = getAuthToken();
+        if (!token) {
+            throw new AuthenticationError();
+        }
+        const baseUrl = getConfigValue("baseUrl") || "https://sendly.live";
+        const timeout = getEffectiveValue("timeout");
+        const url = `${baseUrl}/api/v1/enterprise/verification-document/upload`;
+        const headers = {
+            "Content-Type": `multipart/form-data; boundary=${boundary}`,
+            Accept: "application/json",
+            Authorization: `Bearer ${token}`,
+        };
+        const orgId = getEffectiveValue("currentOrgId");
+        if (orgId) {
+            headers["X-Organization-Id"] = orgId;
+        }
+        const spin = spinner("Uploading verification document...");
+        spin.start();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const resp = await fetch(url, {
+            method: "POST",
+            headers,
+            body,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        const data = (await resp.json().catch(() => ({})));
+        if (!resp.ok) {
+            spin.fail("Upload failed");
+            throw new ApiError(data.error || "upload_error", data.message || `HTTP ${resp.status}`, resp.status);
+        }
+        spin.succeed("Document uploaded");
+        if (isJsonMode()) {
+            json(data);
+            return;
+        }
+        success("Verification document uploaded", {
+            ID: data.id,
+            URL: data.url,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-verification-document.js","sourceRoot":"","sources":["../../../src/commands/enterprise/upload-verification-document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EACL,YAAY,EACZ,cAAc,EACd,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,QAAQ,EACR,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAOlC,MAAM,CAAC,OAAO,OAAO,oCAAqC,SAAQ,oBAAoB;IACpF,MAAM,CAAC,WAAW,GAAG,+CAA+C,CAAC;IAErE,MAAM,CAAC,QAAQ,GAAG;QAChB,mFAAmF;QACnF,kGAAkG;KACnG,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,2CAA2C;YACxD,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC;YAC3B,WAAW,EAAE,6CAA6C;SAC3D,CAAC;QACF,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC;YAC9B,WAAW,EAAE,gDAAgD;SAC9D,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;QAEzE,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,mBAAmB,QAAQ,EAAE,CAAC,CAAC;QAC5C,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QAEjD,IAAI,QAAQ,GAAG,0BAA0B,CAAC;QAC1C,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,OAAO;YAAE,QAAQ,GAAG,YAAY,CAAC;aAC1D,IAAI,GAAG,KAAK,MAAM;YAAE,QAAQ,GAAG,WAAW,CAAC;aAC3C,IAAI,GAAG,KAAK,MAAM;YAAE,QAAQ,GAAG,WAAW,CAAC;aAC3C,IAAI,GAAG,KAAK,MAAM;YAAE,QAAQ,GAAG,iBAAiB,CAAC;aACjD,IAAI,GAAG,KAAK,OAAO;YAAE,QAAQ,GAAG,YAAY,CAAC;QAElD,MAAM,UAAU,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAE7C,MAAM,QAAQ,GAAG,mBAAmB,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3F,MAAM,KAAK,GAAa,EAAE,CAAC;QAE3B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CACpB,KAAK,QAAQ,MAAM;YACnB,0DAA0D,QAAQ,OAAO;YACzE,iBAAiB,QAAQ,UAAU,CACpC,CAAC,CAAC;QACH,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEvB,IAAI,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC;YAC1B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CACpB,SAAS,QAAQ,MAAM;gBACvB,4DAA4D;gBAC5D,KAAK,CAAC,cAAc,CAAC,CACtB,CAAC,CAAC;QACL,CAAC;QAED,IAAI,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC7B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CACpB,SAAS,QAAQ,MAAM;gBACvB,+DAA+D;gBAC/D,KAAK,CAAC,iBAAiB,CAAC,CACzB,CAAC,CAAC;QACL,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,QAAQ,QAAQ,CAAC,CAAC,CAAC;QAEnD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAElC,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;QAC7B,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,mBAAmB,EAAE,CAAC;QAClC,CAAC;QAED,MAAM,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,IAAI,qBAAqB,CAAC;QACnE,MAAM,OAAO,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAC7C,MAAM,GAAG,GAAG,GAAG,OAAO,iDAAiD,CAAC;QAExE,MAAM,OAAO,GAA2B;YACtC,cAAc,EAAE,iCAAiC,QAAQ,EAAE;YAC3D,MAAM,EAAE,kBAAkB;YAC1B,aAAa,EAAE,UAAU,KAAK,EAAE;SACjC,CAAC;QAEF,MAAM,KAAK,GAAG,iBAAiB,CAAC,cAAc,CAAC,CAAC;QAChD,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,CAAC,mBAAmB,CAAC,GAAG,KAAK,CAAC;QACvC,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,oCAAoC,CAAC,CAAC;QAC3D,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,OAAO,CAAC,CAAC;QAEhE,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAC5B,MAAM,EAAE,MAAM;YACd,OAAO;YACP,IAAI;YACJ,MAAM,EAAE,UAAU,CAAC,MAAM;SAC1B,CAAC,CAAC;QAEH,YAAY,CAAC,SAAS,CAAC,CAAC;QAExB,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAGhD,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAC3B,MAAM,IAAI,QAAQ,CAChB,IAAI,CAAC,KAAK,IAAI,cAAc,EAC5B,IAAI,CAAC,OAAO,IAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,EACrC,IAAI,CAAC,MAAM,CACZ,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAElC,IAAI,UAAU,EAAE,EAAE,CAAC;YACjB,IAAI,CAAC,IAAI,CAAC,CAAC;YACX,OAAO;QACT,CAAC;QAED,OAAO,CAAC,gCAAgC,EAAE;YACxC,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC,CAAC;IACL,CAAC","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { success, json, isJsonMode, spinner } from \"../../lib/output.js\";\nimport {\n  getAuthToken,\n  getConfigValue,\n  getEffectiveValue,\n} from \"../../lib/config.js\";\nimport {\n  ApiError,\n  AuthenticationError,\n} from \"../../lib/api-client.js\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\n\ninterface UploadResponse {\n  url: string;\n  id: string;\n}\n\nexport default class EnterpriseUploadVerificationDocument extends AuthenticatedCommand {\n  static description = \"Upload a verification document (image or PDF)\";\n\n  static examples = [\n    '<%= config.bin %> enterprise upload-verification-document --file ./ein-letter.png',\n    '<%= config.bin %> enterprise upload-verification-document --file ./doc.pdf --workspace-id ws_123',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    file: Flags.string({\n      char: \"f\",\n      description: \"Path to the file to upload (image or PDF)\",\n      required: true,\n    }),\n    \"workspace-id\": Flags.string({\n      description: \"Workspace ID to associate the document with\",\n    }),\n    \"verification-id\": Flags.string({\n      description: \"Verification ID to associate the document with\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(EnterpriseUploadVerificationDocument);\n\n    const filePath = flags.file;\n    if (!fs.existsSync(filePath)) {\n      this.error(`File not found: ${filePath}`);\n    }\n\n    const filename = path.basename(filePath);\n    const ext = path.extname(filePath).toLowerCase();\n\n    let mimetype = \"application/octet-stream\";\n    if (ext === \".jpg\" || ext === \".jpeg\") mimetype = \"image/jpeg\";\n    else if (ext === \".png\") mimetype = \"image/png\";\n    else if (ext === \".gif\") mimetype = \"image/gif\";\n    else if (ext === \".pdf\") mimetype = \"application/pdf\";\n    else if (ext === \".webp\") mimetype = \"image/webp\";\n\n    const fileBuffer = fs.readFileSync(filePath);\n\n    const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).substring(2)}`;\n    const parts: Buffer[] = [];\n\n    parts.push(Buffer.from(\n      `--${boundary}\\r\\n` +\n      `Content-Disposition: form-data; name=\"file\"; filename=\"${filename}\"\\r\\n` +\n      `Content-Type: ${mimetype}\\r\\n\\r\\n`,\n    ));\n    parts.push(fileBuffer);\n\n    if (flags[\"workspace-id\"]) {\n      parts.push(Buffer.from(\n        `\\r\\n--${boundary}\\r\\n` +\n        `Content-Disposition: form-data; name=\"workspaceId\"\\r\\n\\r\\n` +\n        flags[\"workspace-id\"],\n      ));\n    }\n\n    if (flags[\"verification-id\"]) {\n      parts.push(Buffer.from(\n        `\\r\\n--${boundary}\\r\\n` +\n        `Content-Disposition: form-data; name=\"verificationId\"\\r\\n\\r\\n` +\n        flags[\"verification-id\"],\n      ));\n    }\n\n    parts.push(Buffer.from(`\\r\\n--${boundary}--\\r\\n`));\n\n    const body = Buffer.concat(parts);\n\n    const token = getAuthToken();\n    if (!token) {\n      throw new AuthenticationError();\n    }\n\n    const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n    const timeout = getEffectiveValue(\"timeout\");\n    const url = `${baseUrl}/api/v1/enterprise/verification-document/upload`;\n\n    const headers: Record<string, string> = {\n      \"Content-Type\": `multipart/form-data; boundary=${boundary}`,\n      Accept: \"application/json\",\n      Authorization: `Bearer ${token}`,\n    };\n\n    const orgId = getEffectiveValue(\"currentOrgId\");\n    if (orgId) {\n      headers[\"X-Organization-Id\"] = orgId;\n    }\n\n    const spin = spinner(\"Uploading verification document...\");\n    spin.start();\n\n    const controller = new AbortController();\n    const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n    const resp = await fetch(url, {\n      method: \"POST\",\n      headers,\n      body,\n      signal: controller.signal,\n    });\n\n    clearTimeout(timeoutId);\n\n    const data = (await resp.json().catch(() => ({}))) as UploadResponse & {\n      error?: string;\n      message?: string;\n    };\n\n    if (!resp.ok) {\n      spin.fail(\"Upload failed\");\n      throw new ApiError(\n        data.error || \"upload_error\",\n        data.message || `HTTP ${resp.status}`,\n        resp.status,\n      );\n    }\n\n    spin.succeed(\"Document uploaded\");\n\n    if (isJsonMode()) {\n      json(data);\n      return;\n    }\n\n    success(\"Verification document uploaded\", {\n      ID: data.id,\n      URL: data.url,\n    });\n  }\n}\n"]}

package/dist/commands/events/listen.d.ts

@@ -0,0 +1,11 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EventsListen extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        types: 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/events/listen.js

@@ -0,0 +1,82 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { getAuthToken, getEffectiveValue } from "../../lib/config.js";
+import { colors, json, isJsonMode } from "../../lib/output.js";
+export default class EventsListen extends AuthenticatedCommand {
+    static description = "Listen to real-time events via Server-Sent Events. Streams message deliveries, conversation updates, and more.";
+    static examples = [
+        "<%= config.bin %> events listen",
+        "<%= config.bin %> events listen --types new_message,conversation_update",
+        "<%= config.bin %> events listen --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        types: Flags.string({
+            description: "Comma-separated event types to filter (default: all)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EventsListen);
+        const apiKey = getAuthToken();
+        const baseUrl = getEffectiveValue("baseUrl");
+        const url = new URL("/api/v1/events", baseUrl);
+        if (flags.types)
+            url.searchParams.set("types", flags.types);
+        if (!isJsonMode()) {
+            console.log(colors.bold("Listening for events..."));
+            console.log(colors.dim(`Endpoint: ${url.toString()}`));
+            if (flags.types)
+                console.log(colors.dim(`Filtering: ${flags.types}`));
+            console.log(colors.dim("Press Ctrl+C to stop\n"));
+        }
+        const response = await fetch(url.toString(), {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!response.ok) {
+            throw new Error(`Connection failed: ${response.status} ${response.statusText}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error("No response stream");
+        const decoder = new TextDecoder();
+        let buffer = "";
+        process.on("SIGINT", () => {
+            reader.cancel();
+            if (!isJsonMode())
+                console.log(colors.dim("\nDisconnected."));
+            process.exit(0);
+        });
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.startsWith("data: "))
+                    continue;
+                const raw = line.slice(6).trim();
+                if (!raw)
+                    continue;
+                try {
+                    const event = JSON.parse(raw);
+                    if (isJsonMode()) {
+                        json(event);
+                    }
+                    else {
+                        const ts = new Date(event.timestamp || Date.now()).toLocaleTimeString();
+                        const type = colors.primary(event.type || "unknown");
+                        console.log(`${colors.dim(ts)}  ${type}`);
+                        if (event.data) {
+                            const preview = JSON.stringify(event.data).slice(0, 120);
+                            console.log(`  ${colors.dim(preview)}${JSON.stringify(event.data).length > 120 ? "..." : ""}`);
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listen.js","sourceRoot":"","sources":["../../../src/commands/events/listen.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { getAuthToken, getEffectiveValue } from \"../../lib/config.js\";\nimport { colors, json, isJsonMode } from \"../../lib/output.js\";\n\nexport default class EventsListen extends AuthenticatedCommand {\n  static description =\n    \"Listen to real-time events via Server-Sent Events. Streams message deliveries, conversation updates, and more.\";\n\n  static examples = [\n    \"<%= config.bin %> events listen\",\n    \"<%= config.bin %> events listen --types new_message,conversation_update\",\n    \"<%= config.bin %> events listen --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    types: Flags.string({\n      description: \"Comma-separated event types to filter (default: all)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(EventsListen);\n\n    const apiKey = getAuthToken();\n    const baseUrl = getEffectiveValue(\"baseUrl\");\n\n    const url = new URL(\"/api/v1/events\", baseUrl);\n    if (flags.types) url.searchParams.set(\"types\", flags.types);\n\n    if (!isJsonMode()) {\n      console.log(colors.bold(\"Listening for events...\"));\n      console.log(colors.dim(`Endpoint: ${url.toString()}`));\n      if (flags.types) console.log(colors.dim(`Filtering: ${flags.types}`));\n      console.log(colors.dim(\"Press Ctrl+C to stop\\n\"));\n    }\n\n    const response = await fetch(url.toString(), {\n      headers: { Authorization: `Bearer ${apiKey}` },\n    });\n\n    if (!response.ok) {\n      throw new Error(`Connection failed: ${response.status} ${response.statusText}`);\n    }\n\n    const reader = response.body?.getReader();\n    if (!reader) throw new Error(\"No response stream\");\n\n    const decoder = new TextDecoder();\n    let buffer = \"\";\n\n    process.on(\"SIGINT\", () => {\n      reader.cancel();\n      if (!isJsonMode()) console.log(colors.dim(\"\\nDisconnected.\"));\n      process.exit(0);\n    });\n\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) break;\n\n      buffer += decoder.decode(value, { stream: true });\n      const lines = buffer.split(\"\\n\");\n      buffer = lines.pop() || \"\";\n\n      for (const line of lines) {\n        if (!line.startsWith(\"data: \")) continue;\n        const raw = line.slice(6).trim();\n        if (!raw) continue;\n\n        try {\n          const event = JSON.parse(raw);\n\n          if (isJsonMode()) {\n            json(event);\n          } else {\n            const ts = new Date(event.timestamp || Date.now()).toLocaleTimeString();\n            const type = colors.primary(event.type || \"unknown\");\n            console.log(`${colors.dim(ts)}  ${type}`);\n            if (event.data) {\n              const preview = JSON.stringify(event.data).slice(0, 120);\n              console.log(`  ${colors.dim(preview)}${JSON.stringify(event.data).length > 120 ? \"...\" : \"\"}`);\n            }\n          }\n        } catch {}\n      }\n    }\n  }\n}\n"]}

package/dist/commands/labels/add.d.ts

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

@@ -0,0 +1,46 @@
+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 LabelsAdd extends AuthenticatedCommand {
+    static description = "Add a label to a conversation";
+    static examples = [
+        "<%= config.bin %> labels add conv_abc123 lbl_def456",
+        "<%= config.bin %> labels add conv_abc123 lbl_def456 --json",
+    ];
+    static args = {
+        conversationId: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+        labelId: Args.string({
+            description: "Label ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(LabelsAdd);
+        const spin = spinner("Adding label...");
+        spin.start();
+        try {
+            const response = await apiClient.post(`/api/v1/conversations/${encodeURIComponent(args.conversationId)}/labels`, { labelIds: [args.labelId] });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Label added to conversation", {
+                "Conversation ID": args.conversationId,
+                "Label ID": args.labelId,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/labels/remove.d.ts

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

@@ -0,0 +1,46 @@
+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 LabelsRemove extends AuthenticatedCommand {
+    static description = "Remove a label from a conversation";
+    static examples = [
+        "<%= config.bin %> labels remove conv_abc123 lbl_def456",
+        "<%= config.bin %> labels remove conv_abc123 lbl_def456 --json",
+    ];
+    static args = {
+        conversationId: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+        labelId: Args.string({
+            description: "Label ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(LabelsRemove);
+        const spin = spinner("Removing label...");
+        spin.start();
+        try {
+            const response = await apiClient.delete(`/api/v1/conversations/${encodeURIComponent(args.conversationId)}/labels/${encodeURIComponent(args.labelId)}`);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Label removed from conversation", {
+                "Conversation ID": args.conversationId,
+                "Label ID": args.labelId,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/rules/create.d.ts

@@ -0,0 +1,16 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class RulesCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        intent: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        sentiment: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        close: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        priority: 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/rules/create.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, isJsonMode, success, keyValue, header } from "../../lib/output.js";
+export default class RulesCreate extends AuthenticatedCommand {
+    static description = "Create an auto-labeling rule";
+    static examples = [
+        '<%= config.bin %> rules create --name "Flag complaints" --intent complaint --label label_abc',
+        '<%= config.bin %> rules create --name "Close opt-outs" --intent opt_out --close',
+        '<%= config.bin %> rules create --name "Negative" --sentiment negative --label label_xyz --priority 1',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            description: "Rule name",
+            required: true,
+        }),
+        intent: Flags.string({
+            description: "Match intent (question, appointment, complaint, order_status, feedback, opt_out, greeting, confirmation, other)",
+            multiple: true,
+        }),
+        sentiment: Flags.string({
+            description: "Match sentiment (positive, neutral, negative)",
+            multiple: true,
+        }),
+        label: Flags.string({
+            description: "Label ID to apply when rule matches",
+            multiple: true,
+        }),
+        close: Flags.boolean({
+            description: "Close the conversation when rule matches",
+            default: false,
+        }),
+        priority: Flags.integer({
+            description: "Priority (lower runs first)",
+            default: 0,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(RulesCreate);
+        const conditions = {};
+        if (flags.intent?.length)
+            conditions.intent = flags.intent.length === 1 ? flags.intent[0] : flags.intent;
+        if (flags.sentiment?.length)
+            conditions.sentiment = flags.sentiment.length === 1 ? flags.sentiment[0] : flags.sentiment;
+        const actions = {};
+        if (flags.label?.length)
+            actions.addLabels = flags.label;
+        if (flags.close)
+            actions.closeConversation = true;
+        const rule = await apiClient.post("/api/v1/rules", {
+            name: flags.name,
+            conditions,
+            actions,
+            priority: flags.priority,
+        });
+        if (isJsonMode()) {
+            json(rule);
+            return;
+        }
+        success(`Rule "${flags.name}" created`);
+        header("Rule Details");
+        keyValue({
+            ID: rule.id,
+            Name: rule.name,
+            Priority: rule.priority,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/rules/delete.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class RulesDelete 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/rules/delete.js

@@ -0,0 +1,29 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, isJsonMode, success } from "../../lib/output.js";
+export default class RulesDelete extends AuthenticatedCommand {
+    static description = "Delete an auto-labeling rule";
+    static examples = [
+        "<%= config.bin %> rules delete rule_abc123",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Rule ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(RulesDelete);
+        await apiClient.delete(`/api/v1/rules/${encodeURIComponent(args.id)}`);
+        if (isJsonMode()) {
+            json({ success: true, id: args.id });
+            return;
+        }
+        success("Rule deleted");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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