@commissionsight/cli 0.1.0

package/dist/commands/member.js

@@ -0,0 +1,91 @@
+import { cover } from './registry.js';
+import { resolveCarrier } from '../lib/resolve.js';
+import { parsePeriod } from '../lib/period.js';
+import { makePrinter } from '../output/print.js';
+import { optStr } from '../util.js';
+export function memberCommands() {
+    cover('listMembers', 'cs member list');
+    cover('getMember', 'cs member get');
+    cover('getMemberTimeline', 'cs member timeline');
+    cover('getMemberJourney', 'cs member journey');
+    cover('getMemberLastSeen', 'cs member last-seen');
+    cover('getPolicyJourney', 'cs policy journey');
+    return [
+        {
+            path: ['member', 'list'],
+            summary: 'List members (filter by carrier/status/period)',
+            options: {
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+                status: { type: 'string', desc: 'Filter by status', choices: ['green', 'yellow', 'red'], placeholder: '<s>' },
+                period: { type: 'string', desc: 'Filter by period YYYY-MM', placeholder: '<YYYY-MM>' },
+            },
+            async run(ctx, parsed) {
+                const carrier = optStr(parsed.options['carrier']);
+                const period = optStr(parsed.options['period']);
+                const p = period ? parsePeriod(period) : undefined;
+                const page = await ctx.client().listMembers({
+                    ...(carrier ? { carrierId: await resolveCarrier(ctx, carrier) } : {}),
+                    ...(optStr(parsed.options['status']) ? { status: optStr(parsed.options['status']) } : {}),
+                    ...(p ? { periodYear: p.periodYear, periodMonth: p.periodMonth } : {}),
+                });
+                return page.data;
+            },
+        },
+        {
+            path: ['member', 'get'],
+            summary: 'Get a member by ref id',
+            args: [{ name: 'memberRefId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().getMember(parsed.args[0]);
+            },
+        },
+        {
+            path: ['member', 'timeline'],
+            summary: 'Period-by-period timeline for a member',
+            args: [{ name: 'memberRefId', required: true }],
+            async run(ctx, parsed) {
+                return (await ctx.client().getMemberTimeline(parsed.args[0])).data;
+            },
+        },
+        {
+            path: ['member', 'journey'],
+            summary: 'Full audit journey of a member',
+            args: [{ name: 'memberRefId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().getMemberJourney(parsed.args[0]);
+            },
+            render: renderJourney,
+        },
+        {
+            path: ['member', 'last-seen'],
+            summary: 'Where/when a member was last seen',
+            args: [{ name: 'memberRefId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().getMemberLastSeen(parsed.args[0]);
+            },
+        },
+        {
+            path: ['policy', 'journey'],
+            summary: 'Full audit journey of a single policy',
+            args: [{ name: 'policyRefId', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().getPolicyJourney(parsed.args[0]);
+            },
+            render: renderJourney,
+        },
+    ];
+}
+function renderJourney(data, ctx) {
+    const j = data;
+    const p = makePrinter(ctx.io, ctx.globals.color);
+    p.line(p.paint('bold', `${j.member.memberName ?? j.memberRefId}`) +
+        `  ${j.firstPeriod ?? '?'} → ${j.latestPeriod ?? '?'}  (${j.periodCount} periods)`);
+    p.table(j.periods.map((per) => ({
+        period: per.period,
+        status: per.status ?? '—',
+        present: per.present,
+        commission: per.commissionAmount ?? '—',
+        flags: per.flags.join('|'),
+        file: per.file?.fileName ?? '—',
+    })), ['period', 'status', 'present', 'commission', 'flags', 'file']);
+}

package/dist/commands/meta.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Introspection & DX commands (plan §6.13): `cs version` and `cs schema`.
+ * Both are local (no API call). `cs schema` is built from the live command
+ * table so an AI harness can discover the full surface programmatically.
+ */
+import type { Cmd } from '../types.js';
+export declare function metaCommands(getTable: () => Cmd[]): Cmd[];

package/dist/commands/meta.js

@@ -0,0 +1,36 @@
+import { cliVersion, sdkVersion } from '../version.js';
+import { buildSchema } from '../output/schema-tree.js';
+import { makePrinter } from '../output/print.js';
+export function metaCommands(getTable) {
+    return [
+        {
+            path: ['version'],
+            summary: 'Print the CLI and resolved SDK version',
+            async run() {
+                return { cli: cliVersion(), sdk: sdkVersion() };
+            },
+            render(data, ctx) {
+                const d = data;
+                ctx.io.stdout(`cs ${d.cli} (@commissionsight/sdk ${d.sdk})\n`);
+            },
+        },
+        {
+            path: ['schema'],
+            summary: 'Emit the full command/flag tree (for humans or AI harnesses)',
+            async run() {
+                return buildSchema(getTable(), cliVersion());
+            },
+            render(data, ctx) {
+                const doc = data;
+                const p = makePrinter(ctx.io, ctx.globals.color);
+                p.line(p.paint('bold', `cs ${doc.version} — ${doc.commands.length} commands`));
+                p.line();
+                p.table(doc.commands.map((c) => ({
+                    command: c.command,
+                    args: c.args.map((a) => (a.required ? `<${a.name}>` : `[${a.name}]`)).join(' '),
+                    summary: c.summary,
+                })), ['command', 'args', 'summary']);
+            },
+        },
+    ];
+}

package/dist/commands/rate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Expected-commission-rate commands (plan §6.9).
+ */
+import type { Cmd } from '../types.js';
+export declare function rateCommands(): Cmd[];

package/dist/commands/rate.js

@@ -0,0 +1,69 @@
+import { cover } from './registry.js';
+import { resolveCarrier } from '../lib/resolve.js';
+import { confirmDestructive } from '../lib/confirm.js';
+import { UsageError } from '../errors.js';
+import { optStr } from '../util.js';
+const RATE_TYPES = ['percent_of_premium', 'flat_per_member'];
+export function rateCommands() {
+    cover('listExpectedRates', 'cs rate list');
+    cover('upsertExpectedRate', 'cs rate set');
+    cover('deleteExpectedRate', 'cs rate delete');
+    return [
+        {
+            path: ['rate', 'list'],
+            summary: 'List expected commission rates',
+            options: {
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+            },
+            async run(ctx, parsed) {
+                const carrier = optStr(parsed.options['carrier']);
+                const res = await ctx.client().listExpectedRates(carrier ? await resolveCarrier(ctx, carrier) : undefined);
+                return res.data;
+            },
+        },
+        {
+            path: ['rate', 'set'],
+            summary: 'Upsert a contracted rate (prints rescoredPeriods)',
+            options: {
+                carrier: { type: 'string', desc: 'Carrier (required)', placeholder: '<c>' },
+                plan: { type: 'string', desc: 'Plan code (omit for carrier-wide)', placeholder: '<code>' },
+                type: { type: 'string', desc: 'Rate type', choices: RATE_TYPES, placeholder: '<t>' },
+                value: { type: 'string', desc: 'Fraction (percent) or dollars (flat)', placeholder: '<n>' },
+            },
+            async run(ctx, parsed) {
+                const carrier = optStr(parsed.options['carrier']);
+                const type = optStr(parsed.options['type']);
+                const valueStr = optStr(parsed.options['value']);
+                if (!carrier)
+                    throw new UsageError('--carrier is required');
+                if (!type)
+                    throw new UsageError(`--type is required (${RATE_TYPES.join(' | ')})`);
+                if (valueStr === undefined)
+                    throw new UsageError('--value is required');
+                const rateValue = Number(valueStr);
+                if (!Number.isFinite(rateValue))
+                    throw new UsageError(`invalid --value: ${valueStr}`);
+                if (type === 'percent_of_premium' && rateValue > 1) {
+                    ctx.log(`warning: --value ${rateValue} looks like a percentage; expected a fraction (e.g. 0.20 for 20%)`);
+                }
+                const plan = optStr(parsed.options['plan']);
+                return ctx.client().upsertExpectedRate({
+                    carrierId: await resolveCarrier(ctx, carrier),
+                    ...(plan ? { planCode: plan } : {}),
+                    rateType: type,
+                    rateValue,
+                });
+            },
+        },
+        {
+            path: ['rate', 'delete'],
+            summary: 'Delete an expected rate (destructive)',
+            args: [{ name: 'id', required: true }],
+            async run(ctx, parsed) {
+                await confirmDestructive(ctx, `delete expected rate ${parsed.args[0]}`);
+                await ctx.client().deleteExpectedRate(parsed.args[0]);
+                return { deleted: parsed.args[0] };
+            },
+        },
+    ];
+}

package/dist/commands/registry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The command table — the single source of truth consumed by the router,
+ * `--help`, and `cs schema`. Each phase appends its command modules here.
+ */
+import type { Cmd } from '../types.js';
+export declare function getCommandTable(): Cmd[];
+/**
+ * The backing map of SDK method name → owning command path(s). Used by `cs
+ * schema` consumers and, crucially, by the coverage test (plan §14) that
+ * asserts every public SDK method is reachable. Populated as commands land.
+ */
+export declare const SDK_COVERAGE: Record<string, string>;
+/** Register a command's backing SDK method(s) for the coverage matrix. */
+export declare function cover(methods: string | string[], command: string): void;

package/dist/commands/registry.js

@@ -0,0 +1,56 @@
+import { metaCommands } from './meta.js';
+import { sessionCommands } from './session.js';
+import { authCommands } from './auth.js';
+import { contextCommands } from './context.js';
+import { workspaceCommands } from './workspace.js';
+import { carrierCommands } from './carrier.js';
+import { uploadCommands } from './upload.js';
+import { batchCommands } from './batch.js';
+import { fileCommands } from './file.js';
+import { jobCommands } from './job.js';
+import { memberCommands } from './member.js';
+import { teamCommands } from './team.js';
+import { reportCommands } from './report.js';
+import { rateCommands } from './rate.js';
+import { webhookCommands } from './webhook.js';
+import { billingCommands } from './billing.js';
+import { adminCommands } from './admin.js';
+import { completionCommands } from './completion.js';
+let TABLE = null;
+export function getCommandTable() {
+    if (!TABLE) {
+        const table = [];
+        table.push(...metaCommands(() => getCommandTable()));
+        table.push(...sessionCommands());
+        table.push(...authCommands());
+        table.push(...contextCommands());
+        table.push(...workspaceCommands());
+        table.push(...carrierCommands());
+        table.push(...uploadCommands());
+        table.push(...batchCommands());
+        table.push(...fileCommands());
+        table.push(...jobCommands());
+        table.push(...memberCommands());
+        table.push(...teamCommands());
+        table.push(...reportCommands());
+        table.push(...rateCommands());
+        table.push(...webhookCommands());
+        table.push(...billingCommands());
+        table.push(...adminCommands());
+        table.push(...completionCommands(() => getCommandTable()));
+        TABLE = table;
+    }
+    return TABLE;
+}
+/**
+ * The backing map of SDK method name → owning command path(s). Used by `cs
+ * schema` consumers and, crucially, by the coverage test (plan §14) that
+ * asserts every public SDK method is reachable. Populated as commands land.
+ */
+export const SDK_COVERAGE = {};
+/** Register a command's backing SDK method(s) for the coverage matrix. */
+export function cover(methods, command) {
+    for (const m of Array.isArray(methods) ? methods : [methods]) {
+        SDK_COVERAGE[m] = command;
+    }
+}

package/dist/commands/report.d.ts

@@ -0,0 +1,2 @@
+import type { Cmd } from '../types.js';
+export declare function reportCommands(): Cmd[];

package/dist/commands/report.js

@@ -0,0 +1,168 @@
+/**
+ * Reports (plan §6.8). NOTE: SDK 2.2.0's report methods do not accept a
+ * `workspaceId`, so `--workspace` is intentionally NOT offered here (the docs
+ * expose ?workspaceId at the HTTP layer, but the SDK can't pass it; a thin
+ * wrapper must not bypass the SDK). Lands when the SDK adds the parameter.
+ */
+import { writeFileSync } from 'node:fs';
+import { cover } from './registry.js';
+import { resolveCarrier } from '../lib/resolve.js';
+import { parsePeriod } from '../lib/period.js';
+import { collectOffset } from '../lib/paginate.js';
+import { emitCSV, ATTRITION_COLUMNS, CHARGEBACK_COLUMNS, COMPARISON_COLUMNS, } from '../output/csv.js';
+import { UsageError } from '../errors.js';
+import { optStr, optBool, optNum } from '../util.js';
+const writeF = (p, d) => writeFileSync(p, d);
+export function reportCommands() {
+    cover('rollup', 'cs report rollup');
+    cover('compare', 'cs report compare');
+    cover('attrition', 'cs report attrition');
+    cover('attritionSeries', 'cs report attrition-series');
+    cover('dataQuality', 'cs report data-quality');
+    cover('listChargebacks', 'cs report chargebacks');
+    return [
+        {
+            path: ['report', 'rollup'],
+            summary: 'Period rollup totals (owed, at-risk, chargebacks)',
+            options: {
+                period: { type: 'string', desc: 'Period YYYY-MM (default latest)', placeholder: '<YYYY-MM>' },
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+                csv: { type: 'boolean', desc: 'Emit totals as CSV' },
+                output: { type: 'string', short: 'o', desc: 'CSV output file', placeholder: '<file>' },
+            },
+            async run(ctx, parsed) {
+                const carrier = optStr(parsed.options['carrier']);
+                const period = optStr(parsed.options['period']);
+                if (period)
+                    parsePeriod(period);
+                const res = await ctx.client().rollup(period, carrier ? await resolveCarrier(ctx, carrier) : undefined);
+                if (optBool(parsed.options['csv']) && !ctx.globals.json) {
+                    return emitCSV(ctx.io, [{ period: res.period, ...res.totals }], undefined, optStr(parsed.options['output']), writeF);
+                }
+                return res;
+            },
+        },
+        {
+            path: ['report', 'compare'],
+            summary: 'Compare two periods',
+            options: {
+                from: { type: 'string', desc: 'From period YYYY-MM (required)', placeholder: '<YYYY-MM>' },
+                to: { type: 'string', desc: 'To period YYYY-MM (required)', placeholder: '<YYYY-MM>' },
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+                granularity: { type: 'string', desc: 'Comparison granularity', placeholder: '<g>' },
+                csv: { type: 'boolean', desc: 'Emit rows as CSV' },
+                output: { type: 'string', short: 'o', desc: 'CSV output file', placeholder: '<file>' },
+            },
+            async run(ctx, parsed) {
+                const from = optStr(parsed.options['from']);
+                const to = optStr(parsed.options['to']);
+                if (!from || !to)
+                    throw new UsageError('--from and --to are required (YYYY-MM)');
+                parsePeriod(from);
+                parsePeriod(to);
+                const carrier = optStr(parsed.options['carrier']);
+                const res = await ctx.client().compare({
+                    from,
+                    to,
+                    ...(carrier ? { carrierId: await resolveCarrier(ctx, carrier) } : {}),
+                    ...(optStr(parsed.options['granularity']) ? { granularity: optStr(parsed.options['granularity']) } : {}),
+                });
+                if (optBool(parsed.options['csv']) && !ctx.globals.json) {
+                    return emitCSV(ctx.io, res.data, COMPARISON_COLUMNS, optStr(parsed.options['output']), writeF);
+                }
+                return res;
+            },
+        },
+        {
+            path: ['report', 'attrition'],
+            summary: 'Attrition for a period',
+            options: {
+                period: { type: 'string', desc: 'Period YYYY-MM (required)', placeholder: '<YYYY-MM>' },
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+            },
+            async run(ctx, parsed) {
+                const period = optStr(parsed.options['period']);
+                if (!period)
+                    throw new UsageError('--period YYYY-MM is required');
+                parsePeriod(period);
+                const carrier = optStr(parsed.options['carrier']);
+                return ctx.client().attrition(period, carrier ? await resolveCarrier(ctx, carrier) : undefined);
+            },
+        },
+        {
+            path: ['report', 'attrition-series'],
+            summary: 'Attrition over the last N months',
+            options: {
+                months: { type: 'string', desc: 'Number of months', placeholder: '<n>' },
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+                csv: { type: 'boolean', desc: 'Emit series as CSV' },
+                output: { type: 'string', short: 'o', desc: 'CSV output file', placeholder: '<file>' },
+            },
+            async run(ctx, parsed) {
+                const carrier = optStr(parsed.options['carrier']);
+                const res = await ctx.client().attritionSeries({
+                    ...(optNum(parsed.options['months']) !== undefined ? { months: optNum(parsed.options['months']) } : {}),
+                    ...(carrier ? { carrierId: await resolveCarrier(ctx, carrier) } : {}),
+                });
+                if (optBool(parsed.options['csv']) && !ctx.globals.json) {
+                    return emitCSV(ctx.io, res.data, ATTRITION_COLUMNS, optStr(parsed.options['output']), writeF);
+                }
+                return res.data;
+            },
+        },
+        {
+            path: ['report', 'data-quality'],
+            summary: 'Data-quality signals (ok/watch/alert) by carrier',
+            options: {
+                period: { type: 'string', desc: 'Period YYYY-MM (default latest)', placeholder: '<YYYY-MM>' },
+            },
+            async run(ctx, parsed) {
+                const period = optStr(parsed.options['period']);
+                if (period)
+                    parsePeriod(period);
+                return ctx.client().dataQuality(period);
+            },
+        },
+        {
+            path: ['report', 'chargebacks'],
+            summary: 'Chargebacks for a period (with original payout)',
+            options: {
+                period: { type: 'string', desc: 'Period YYYY-MM', placeholder: '<YYYY-MM>' },
+                carrier: { type: 'string', desc: 'Filter by carrier', placeholder: '<c>' },
+                limit: { type: 'string', desc: 'Page size', placeholder: '<n>' },
+                offset: { type: 'string', desc: 'Offset', placeholder: '<n>' },
+                all: { type: 'boolean', desc: 'Auto-paginate all pages' },
+                csv: { type: 'boolean', desc: 'Emit rows as CSV' },
+                output: { type: 'string', short: 'o', desc: 'CSV output file', placeholder: '<file>' },
+            },
+            async run(ctx, parsed) {
+                const o = parsed.options;
+                const period = optStr(o['period']);
+                if (period)
+                    parsePeriod(period);
+                const carrier = optStr(o['carrier']);
+                const base = {
+                    ...(period ? { period } : {}),
+                    ...(carrier ? { carrierId: await resolveCarrier(ctx, carrier) } : {}),
+                };
+                let rows;
+                if (optBool(o['all'])) {
+                    const { items } = await collectOffset((p) => ctx.client().listChargebacks({ ...base, ...p }));
+                    rows = items;
+                }
+                else {
+                    const res = await ctx.client().listChargebacks({
+                        ...base,
+                        ...(optNum(o['limit']) !== undefined ? { limit: optNum(o['limit']) } : {}),
+                        ...(optNum(o['offset']) !== undefined ? { offset: optNum(o['offset']) } : {}),
+                    });
+                    rows = res.data;
+                }
+                if (optBool(o['csv']) && !ctx.globals.json) {
+                    return emitCSV(ctx.io, rows, CHARGEBACK_COLUMNS, optStr(o['output']), writeF);
+                }
+                return rows;
+            },
+        },
+    ];
+}

package/dist/commands/session.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Session/service commands: `cs whoami` (me) and `cs health` (no auth).
+ */
+import type { Cmd } from '../types.js';
+export declare function sessionCommands(): Cmd[];

package/dist/commands/session.js

@@ -0,0 +1,21 @@
+import { cover } from './registry.js';
+export function sessionCommands() {
+    cover('me', 'cs whoami');
+    cover('health', 'cs health');
+    return [
+        {
+            path: ['whoami'],
+            summary: 'Show the account behind the current token',
+            async run(ctx) {
+                return ctx.client().me();
+            },
+        },
+        {
+            path: ['health'],
+            summary: 'Liveness probe (no auth required)',
+            async run(ctx) {
+                return ctx.client().health();
+            },
+        },
+    ];
+}

package/dist/commands/team.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Team & audit commands (plan §6.7).
+ */
+import type { Cmd } from '../types.js';
+export declare function teamCommands(): Cmd[];

package/dist/commands/team.js

@@ -0,0 +1,61 @@
+import { cover } from './registry.js';
+import { collectOffset } from '../lib/paginate.js';
+import { confirmDestructive } from '../lib/confirm.js';
+import { optStr, optBool, optNum } from '../util.js';
+export function teamCommands() {
+    cover('listTeam', 'cs team list');
+    cover('inviteTeammate', 'cs team invite');
+    cover('removeTeammate', 'cs team remove');
+    cover('listAudit', 'cs audit list');
+    return [
+        {
+            path: ['team', 'list'],
+            summary: 'List account team members',
+            async run(ctx) {
+                return (await ctx.client().listTeam()).data;
+            },
+        },
+        {
+            path: ['team', 'invite'],
+            summary: 'Invite a teammate by email',
+            args: [{ name: 'email', required: true }],
+            async run(ctx, parsed) {
+                return ctx.client().inviteTeammate(parsed.args[0]);
+            },
+        },
+        {
+            path: ['team', 'remove'],
+            summary: 'Remove a teammate (destructive)',
+            args: [{ name: 'userId', required: true }],
+            async run(ctx, parsed) {
+                await confirmDestructive(ctx, `remove teammate ${parsed.args[0]}`);
+                await ctx.client().removeTeammate(parsed.args[0]);
+                return { removed: parsed.args[0] };
+            },
+        },
+        {
+            path: ['audit', 'list'],
+            summary: 'Read the account audit trail (newest first)',
+            options: {
+                action: { type: 'string', desc: 'Filter by dotted action (e.g. file.upload)', placeholder: '<a>' },
+                limit: { type: 'string', desc: 'Page size', placeholder: '<n>' },
+                offset: { type: 'string', desc: 'Offset', placeholder: '<n>' },
+                all: { type: 'boolean', desc: 'Auto-paginate all pages' },
+            },
+            async run(ctx, parsed) {
+                const action = optStr(parsed.options['action']);
+                const base = action ? { action } : {};
+                if (optBool(parsed.options['all'])) {
+                    const { items } = await collectOffset((p) => ctx.client().listAudit({ ...base, ...p }));
+                    return items;
+                }
+                const page = await ctx.client().listAudit({
+                    ...base,
+                    ...(optNum(parsed.options['limit']) !== undefined ? { limit: optNum(parsed.options['limit']) } : {}),
+                    ...(optNum(parsed.options['offset']) !== undefined ? { offset: optNum(parsed.options['offset']) } : {}),
+                });
+                return page.data;
+            },
+        },
+    ];
+}

package/dist/commands/upload.d.ts

@@ -0,0 +1,85 @@
+import type { Cmd } from '../types.js';
+export declare const UPLOAD_OPTIONS: {
+    readonly carrier: {
+        readonly type: "string";
+        readonly desc: "Carrier id|slug|name (required)";
+        readonly placeholder: "<c>";
+    };
+    readonly period: {
+        readonly type: "string";
+        readonly desc: "Statement period YYYY-MM";
+        readonly placeholder: "<YYYY-MM>";
+    };
+    readonly year: {
+        readonly type: "string";
+        readonly desc: "Period year (with --month)";
+        readonly placeholder: "<n>";
+    };
+    readonly month: {
+        readonly type: "string";
+        readonly desc: "Period month (with --year)";
+        readonly placeholder: "<n>";
+    };
+    readonly workspace: {
+        readonly type: "string";
+        readonly desc: "Target workspace id|name";
+        readonly placeholder: "<w>";
+    };
+    readonly replace: {
+        readonly type: "boolean";
+        readonly desc: "Replace an existing carrier+period atomically";
+    };
+    readonly webhook: {
+        readonly type: "string";
+        readonly desc: "Webhook URL for job events";
+        readonly placeholder: "<url>";
+    };
+    readonly 'idempotency-key': {
+        readonly type: "string";
+        readonly desc: "Override the derived idempotency key";
+        readonly placeholder: "<k>";
+    };
+    readonly wait: {
+        readonly type: "boolean";
+        readonly desc: "Poll the job to a terminal state";
+    };
+    readonly timeout: {
+        readonly type: "string";
+        readonly desc: "Wait timeout seconds (default 300)";
+        readonly placeholder: "<s>";
+    };
+    readonly interval: {
+        readonly type: "string";
+        readonly desc: "Poll interval seconds (default 2)";
+        readonly placeholder: "<s>";
+    };
+    readonly results: {
+        readonly type: "boolean";
+        readonly desc: "Dump scored rows on completion (implies --wait)";
+    };
+    readonly status: {
+        readonly type: "string";
+        readonly desc: "Filter results by status";
+        readonly choices: readonly ["green", "yellow", "red"];
+        readonly placeholder: "<s>";
+    };
+    readonly 'owed-only': {
+        readonly type: "boolean";
+        readonly desc: "Only rows with commission owed";
+    };
+    readonly chargeback: {
+        readonly type: "boolean";
+        readonly desc: "Only chargeback rows";
+    };
+    readonly csv: {
+        readonly type: "boolean";
+        readonly desc: "Emit results as CSV (with --results)";
+    };
+    readonly output: {
+        readonly type: "string";
+        readonly short: "o";
+        readonly desc: "Write CSV to a file";
+        readonly placeholder: "<file>";
+    };
+};
+export declare function uploadCommands(): Cmd[];