@autifyhq/aximo-cli 0.1.0

package/dist/commands/schema.js

@@ -0,0 +1,146 @@
+import { defineCommand } from "citty";
+import { formatSuccess, formatError, printResult } from "../output.js";
+import pkg from "../../package.json" with { type: "json" };
+function arg(name, type, description, required = false) {
+    return { name, type, description, required };
+}
+const MUTATE_ARGS = [
+    arg("json", "string", "Raw JSON request body (replaces individual flags)"),
+    arg("dry-run", "boolean", "Validate and show request without calling API"),
+];
+function cmd(name, description, args = [], subCommands) {
+    const schema = { name, description, args };
+    if (subCommands && subCommands.length > 0)
+        schema.subCommands = subCommands;
+    return schema;
+}
+export function getSchema() {
+    return {
+        name: "aximo",
+        version: pkg.version,
+        commands: [
+            cmd("health", "Health commands", [], [cmd("check", "GET /api/health")]),
+            cmd("session", "Session commands", [], [
+                cmd("create", "POST /api/sessions", [
+                    arg("title", "string", "Session title"),
+                    arg("prompt", "string", "Session prompt"),
+                    arg("project-id", "string", "Project ID"),
+                    arg("platform", "string", "ANDROID | IOS"),
+                    arg("model", "string", ""),
+                    arg("start-url", "string", ""),
+                    arg("case-id", "string", ""),
+                    arg("tags", "string", "comma-separated"),
+                    arg("device-arn", "string", ""),
+                    arg("device-name", "string", ""),
+                    arg("upload-arn", "string", ""),
+                    arg("upload-type", "string", "ANDROID_APP | IOS_APP"),
+                    arg("app-name", "string", ""),
+                    arg("bundle-id", "string", ""),
+                    ...MUTATE_ARGS,
+                ]),
+                cmd("get", "GET /api/sessions/{sessionId}", [
+                    arg("sessionId", "positional", "Session ID", true),
+                ]),
+            ]),
+            cmd("trigger", "Trigger commands", [], [
+                cmd("case", "Case trigger commands", [], [
+                    cmd("run", "POST /api/triggers/cases/{caseId}/run", [
+                        arg("caseId", "positional", "Case ID", true),
+                        arg("model", "string", ""),
+                        arg("hostname-override-ids", "string", "comma-separated"),
+                        arg("device-arn", "string", ""),
+                        arg("device-name", "string", ""),
+                        arg("platform", "string", ""),
+                        arg("upload-arn", "string", ""),
+                        arg("upload-type", "string", ""),
+                        arg("app-name", "string", ""),
+                        ...MUTATE_ARGS,
+                    ]),
+                    cmd("get", "GET /api/triggers/cases/{caseId}/sessions/{sessionId}", [
+                        arg("caseId", "positional", "Case ID", true),
+                        arg("sessionId", "positional", "Session ID", true),
+                    ]),
+                ]),
+                cmd("plan", "Plan trigger commands", [], [
+                    cmd("run", "POST /api/triggers/plans/{planId}/run", [
+                        arg("planId", "positional", "Plan ID", true),
+                        arg("model", "string", ""),
+                        arg("mobile-config", "string", "JSON object string"),
+                        ...MUTATE_ARGS,
+                    ]),
+                    cmd("get", "GET /api/triggers/plans/{planId}/runs/{planRunId}", [
+                        arg("planId", "positional", "Plan ID", true),
+                        arg("planRunId", "positional", "Plan Run ID", true),
+                    ]),
+                ]),
+            ]),
+            cmd("device", "Device commands", [], [
+                cmd("list", "GET /api/devices", [
+                    arg("platform", "string", "ANDROID | IOS"),
+                    arg("available-only", "boolean", ""),
+                ]),
+            ]),
+            cmd("upload", "Upload commands", [], [
+                cmd("create", "POST /api/uploads", [
+                    arg("file-name", "string", "File name"),
+                    arg("file-size", "string", "File size in bytes"),
+                    arg("platform", "string", "ANDROID | IOS"),
+                    ...MUTATE_ARGS,
+                ]),
+                cmd("list", "GET /api/uploads", [arg("file-type", "string", "ANDROID_APP | IOS_APP")]),
+                cmd("get", "GET /api/uploads/{uploadId}", [
+                    arg("uploadId", "positional", "Upload ID", true),
+                ]),
+                cmd("put", "PUT /api/uploads/{uploadId} (octet-stream)", [
+                    arg("uploadId", "positional", "Upload ID", true),
+                    arg("file", "string", "Local path to the file"),
+                    arg("dry-run", "boolean", "Validate and show request without calling API"),
+                ]),
+                cmd("submit", "POST /api/uploads/{uploadId}/submit", [
+                    arg("uploadId", "positional", "Upload ID", true),
+                    arg("dry-run", "boolean", "Validate and show request without calling API"),
+                ]),
+            ]),
+            cmd("project", "Project commands", [], [cmd("list", "GET /api/organizations/projects")]),
+            cmd("schema", "Show CLI schema for agent introspection", [
+                arg("command", "positional", "Command path (e.g. session.create)"),
+            ]),
+        ],
+    };
+}
+export function lookupCommand(path) {
+    const parts = path.split(".");
+    let commands = getSchema().commands;
+    let found;
+    for (const part of parts) {
+        found = commands.find((c) => c.name === part);
+        if (!found)
+            return undefined;
+        commands = found.subCommands ?? [];
+    }
+    return found;
+}
+export default defineCommand({
+    meta: { name: "schema", description: "Show CLI schema for agent introspection" },
+    args: {
+        command: {
+            type: "positional",
+            description: "Command path (e.g. session.create)",
+            required: false,
+        },
+    },
+    run({ args }) {
+        if (args.command) {
+            const found = lookupCommand(args.command);
+            if (found) {
+                printResult(formatSuccess(found));
+            }
+            else {
+                printResult(formatError("not_found", `Command '${args.command}' not found`, false));
+            }
+        }
+        else {
+            printResult(formatSuccess({ commands: getSchema().commands }));
+        }
+    },
+});

package/dist/commands/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/schema.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { getSchema, lookupCommand } from "./schema.js";
+describe("getSchema", () => {
+    it("returns aximo with commands", () => {
+        const s = getSchema();
+        expect(s.name).toBe("aximo");
+        expect(s.commands.length).toBeGreaterThan(0);
+        expect(s.commands.find((c) => c.name === "schema")).toBeDefined();
+    });
+    it("advertises --json and --dry-run on mutating commands", () => {
+        const sessionCreate = lookupCommand("session.create");
+        expect(sessionCreate).toBeDefined();
+        const argNames = sessionCreate?.args.map((a) => a.name) ?? [];
+        expect(argNames).toContain("json");
+        expect(argNames).toContain("dry-run");
+        for (const path of ["trigger.case.run", "trigger.plan.run", "upload.create"]) {
+            const c = lookupCommand(path);
+            const names = c?.args.map((a) => a.name) ?? [];
+            expect(names, path).toContain("json");
+            expect(names, path).toContain("dry-run");
+        }
+        for (const path of ["upload.put", "upload.submit"]) {
+            const c = lookupCommand(path);
+            const names = c?.args.map((a) => a.name) ?? [];
+            expect(names, path).toContain("dry-run");
+        }
+    });
+});
+describe("lookupCommand", () => {
+    it("resolves dotted paths", () => {
+        expect(lookupCommand("session.create")?.name).toBe("create");
+        expect(lookupCommand("trigger.case.run")?.name).toBe("run");
+    });
+    it("returns undefined for unknown", () => {
+        expect(lookupCommand("nope")).toBeUndefined();
+        expect(lookupCommand("session.nope")).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,78 @@
+import type { Envelope, CreateSessionResult } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+export interface CreateSessionOptions {
+    title?: unknown;
+    prompt?: unknown;
+    projectId?: unknown;
+    platform?: unknown;
+    model?: unknown;
+    startUrl?: unknown;
+    caseId?: unknown;
+    tags?: unknown;
+    deviceArn?: unknown;
+    deviceName?: unknown;
+    uploadArn?: unknown;
+    uploadType?: unknown;
+    appName?: unknown;
+    bundleId?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runSessionCreate(options: CreateSessionOptions, deps?: ClientDeps): Promise<Envelope<CreateSessionResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly prompt: {
+        readonly type: "string";
+    };
+    readonly "project-id": {
+        readonly type: "string";
+    };
+    readonly platform: {
+        readonly type: "string";
+        readonly description: "ANDROID | IOS";
+    };
+    readonly model: {
+        readonly type: "string";
+    };
+    readonly "start-url": {
+        readonly type: "string";
+    };
+    readonly "case-id": {
+        readonly type: "string";
+    };
+    readonly tags: {
+        readonly type: "string";
+        readonly description: "comma-separated";
+    };
+    readonly "device-arn": {
+        readonly type: "string";
+    };
+    readonly "device-name": {
+        readonly type: "string";
+    };
+    readonly "upload-arn": {
+        readonly type: "string";
+    };
+    readonly "upload-type": {
+        readonly type: "string";
+        readonly description: "ANDROID_APP | IOS_APP";
+    };
+    readonly "app-name": {
+        readonly type: "string";
+    };
+    readonly "bundle-id": {
+        readonly type: "string";
+    };
+    readonly json: {
+        readonly type: "string";
+        readonly description: "Raw JSON request body (replaces individual flags)";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/session/create.js

@@ -0,0 +1,89 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { requireString, optionalString, parsePlatform, parseFileType, parseTags, } from "../../validate.js";
+import { dryRunEnvelope, resolveJsonOverride } from "../../mutate.js";
+export async function runSessionCreate(options, deps) {
+    let body;
+    const override = resolveJsonOverride(options.json);
+    if (override && "error" in override)
+        return override.error;
+    if (override) {
+        body = override.body;
+    }
+    else {
+        try {
+            body = {
+                title: requireString("title", options.title),
+                prompt: requireString("prompt", options.prompt),
+                projectId: requireString("projectId", options.projectId),
+                platform: parsePlatform(options.platform),
+                model: optionalString("model", options.model),
+                startUrl: optionalString("startUrl", options.startUrl),
+                caseId: optionalString("caseId", options.caseId),
+                tags: parseTags(options.tags),
+                deviceArn: optionalString("deviceArn", options.deviceArn),
+                deviceName: optionalString("deviceName", options.deviceName),
+                uploadArn: optionalString("uploadArn", options.uploadArn),
+                uploadType: parseFileType(options.uploadType),
+                appName: optionalString("appName", options.appName),
+                bundleId: optionalString("bundleId", options.bundleId),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", "/api/sessions", body);
+    }
+    try {
+        const res = await request("/api/sessions", { method: "POST", body }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "create", description: "Create an Aximo session" },
+    args: {
+        title: { type: "string" },
+        prompt: { type: "string" },
+        "project-id": { type: "string" },
+        platform: { type: "string", description: "ANDROID | IOS" },
+        model: { type: "string" },
+        "start-url": { type: "string" },
+        "case-id": { type: "string" },
+        tags: { type: "string", description: "comma-separated" },
+        "device-arn": { type: "string" },
+        "device-name": { type: "string" },
+        "upload-arn": { type: "string" },
+        "upload-type": { type: "string", description: "ANDROID_APP | IOS_APP" },
+        "app-name": { type: "string" },
+        "bundle-id": { type: "string" },
+        json: { type: "string", description: "Raw JSON request body (replaces individual flags)" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runSessionCreate({
+            title: args.title,
+            prompt: args.prompt,
+            projectId: args["project-id"],
+            platform: args.platform,
+            model: args.model,
+            startUrl: args["start-url"],
+            caseId: args["case-id"],
+            tags: args.tags,
+            deviceArn: args["device-arn"],
+            deviceName: args["device-name"],
+            uploadArn: args["upload-arn"],
+            uploadType: args["upload-type"],
+            appName: args["app-name"],
+            bundleId: args["bundle-id"],
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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

@@ -0,0 +1,11 @@
+import type { Envelope, Session } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+export declare function runSessionGet(sessionIdInput: unknown, deps?: ClientDeps): Promise<Envelope<Session>>;
+declare const _default: import("citty").CommandDef<{
+    readonly sessionId: {
+        readonly type: "positional";
+        readonly description: "Session ID";
+        readonly required: true;
+    };
+}>;
+export default _default;

package/dist/commands/session/get.js

@@ -0,0 +1,30 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { requireId } from "../../validate.js";
+export async function runSessionGet(sessionIdInput, deps) {
+    let sessionId;
+    try {
+        sessionId = requireId("sessionId", sessionIdInput);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    try {
+        const res = await request(`/api/sessions/${encodeURIComponent(sessionId)}`, {}, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "get", description: "Get a session by id" },
+    args: {
+        sessionId: { type: "positional", description: "Session ID", required: true },
+    },
+    async run({ args }) {
+        printResult(await runSessionGet(args.sessionId));
+    },
+});

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

@@ -0,0 +1,2 @@
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/session/index.js

@@ -0,0 +1,8 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "session", description: "Session commands" },
+    subCommands: {
+        create: () => import("./create.js").then((m) => m.default),
+        get: () => import("./get.js").then((m) => m.default),
+    },
+});

package/dist/commands/session/session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/session/session.test.js

@@ -0,0 +1,128 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runSessionCreate } from "./create.js";
+import { runSessionGet } from "./get.js";
+beforeAll(() => {
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+const MIN = {
+    title: "t",
+    prompt: "p",
+    projectId: "proj-1",
+};
+describe("runSessionCreate", () => {
+    it("POSTs body and returns success envelope", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, sessionId: "s1" }, { status: 201 });
+        }));
+        const result = await runSessionCreate({ ...MIN, platform: "IOS", tags: "a,b" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.sessionId).toBe("s1");
+        expect(seen).toMatchObject({
+            title: "t",
+            prompt: "p",
+            projectId: "proj-1",
+            platform: "IOS",
+            tags: ["a", "b"],
+        });
+    });
+    it("rejects missing title", async () => {
+        const result = await runSessionCreate({ prompt: "p", projectId: "x" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects invalid platform", async () => {
+        const result = await runSessionCreate({ ...MIN, platform: "BAD" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--json replaces individual flags and POSTs raw body", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, sessionId: "s2" }, { status: 201 });
+        }));
+        const raw = JSON.stringify({ title: "raw", prompt: "rp", projectId: "p1", extra: true });
+        const result = await runSessionCreate({ json: raw });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ title: "raw", prompt: "rp", projectId: "p1", extra: true });
+    });
+    it("--json invalid returns validation_error with openapi hint", async () => {
+        const result = await runSessionCreate({ json: "{bad" });
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("validation_error");
+            expect(result.error.hint).toContain("openapi.yaml");
+        }
+    });
+    it("--dry-run returns request without calling API", async () => {
+        const result = await runSessionCreate({ ...MIN, dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.dryRun).toBe(true);
+            expect(result.data.method).toBe("POST");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/sessions`);
+        }
+    });
+    it("returns envelope (not throw) when AXIMO_API_KEY unset", async () => {
+        const prev = process.env["AXIMO_API_KEY"];
+        delete process.env["AXIMO_API_KEY"];
+        try {
+            const result = await runSessionCreate(MIN);
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error.code).toBe("unauthorized");
+                expect(result.error.message).toContain("AXIMO_API_KEY");
+                expect(result.error.hint).toContain("AXIMO_API_KEY");
+            }
+        }
+        finally {
+            if (prev !== undefined)
+                process.env["AXIMO_API_KEY"] = prev;
+        }
+    });
+    it("maps 401 to unauthorized", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions`, () => HttpResponse.json({ error: "Unauthorized" }, { status: 401 })));
+        const result = await runSessionCreate(MIN);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("unauthorized");
+    });
+});
+describe("runSessionGet", () => {
+    it("fetches session by id", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/s1`, () => HttpResponse.json({ id: "s1", status: "running" })));
+        const result = await runSessionGet("s1");
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.data.id).toBe("s1");
+    });
+    it("rejects empty id", async () => {
+        const result = await runSessionGet("");
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects injected query chars in id (requireId)", async () => {
+        const result = await runSessionGet("s1?fields=name");
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("maps 404", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/missing`, () => HttpResponse.json({ error: "Not found" }, { status: 404 })));
+        const result = await runSessionGet("missing");
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+});

package/dist/commands/trigger/case/get.d.ts

@@ -0,0 +1,14 @@
+import type { Envelope, CaseRunStatus } from "../../../types.js";
+import { type ClientDeps } from "../../../client.js";
+export declare function runTriggerCaseGet(caseIdInput: unknown, sessionIdInput: unknown, deps?: ClientDeps): Promise<Envelope<CaseRunStatus>>;
+declare const _default: import("citty").CommandDef<{
+    readonly caseId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+    readonly sessionId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+}>;
+export default _default;

package/dist/commands/trigger/case/get.js

@@ -0,0 +1,33 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../../output.js";
+import { handleApiError } from "../../../errors.js";
+import { request } from "../../../client.js";
+import { requireId } from "../../../validate.js";
+export async function runTriggerCaseGet(caseIdInput, sessionIdInput, deps) {
+    let caseId;
+    let sessionId;
+    try {
+        caseId = requireId("caseId", caseIdInput);
+        sessionId = requireId("sessionId", sessionIdInput);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    try {
+        const res = await request(`/api/triggers/cases/${encodeURIComponent(caseId)}/sessions/${encodeURIComponent(sessionId)}`, {}, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "get", description: "Get status of a case run session" },
+    args: {
+        caseId: { type: "positional", required: true },
+        sessionId: { type: "positional", required: true },
+    },
+    async run({ args }) {
+        printResult(await runTriggerCaseGet(args.caseId, args.sessionId));
+    },
+});

package/dist/commands/trigger/case/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/trigger/case/index.js

@@ -0,0 +1,8 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "case", description: "Case trigger commands" },
+    subCommands: {
+        run: () => import("./run.js").then((m) => m.default),
+        get: () => import("./get.js").then((m) => m.default),
+    },
+});

package/dist/commands/trigger/case/run.d.ts

@@ -0,0 +1,58 @@
+import type { Envelope, CaseRunResult } from "../../../types.js";
+import { type ClientDeps } from "../../../client.js";
+import { type DryRunResult } from "../../../mutate.js";
+export interface TriggerCaseRunOptions {
+    caseId?: unknown;
+    model?: unknown;
+    hostnameOverrideIds?: unknown;
+    deviceArn?: unknown;
+    deviceName?: unknown;
+    platform?: unknown;
+    uploadArn?: unknown;
+    uploadType?: unknown;
+    appName?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runTriggerCaseRun(options: TriggerCaseRunOptions, deps?: ClientDeps): Promise<Envelope<CaseRunResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly caseId: {
+        readonly type: "positional";
+        readonly description: "Case ID";
+        readonly required: true;
+    };
+    readonly model: {
+        readonly type: "string";
+    };
+    readonly "hostname-override-ids": {
+        readonly type: "string";
+        readonly description: "comma-separated";
+    };
+    readonly "device-arn": {
+        readonly type: "string";
+    };
+    readonly "device-name": {
+        readonly type: "string";
+    };
+    readonly platform: {
+        readonly type: "string";
+    };
+    readonly "upload-arn": {
+        readonly type: "string";
+    };
+    readonly "upload-type": {
+        readonly type: "string";
+    };
+    readonly "app-name": {
+        readonly type: "string";
+    };
+    readonly json: {
+        readonly type: "string";
+        readonly description: "Raw JSON request body";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;