adapty 0.11.0 → 0.12.0

package/dist/cli/commands/analytics/ltv.js

@@ -0,0 +1,40 @@
+import { validateLtv } from '../../../sdk/adapty/index.js';
+import { assertValid } from '../../../sdk/core/validation.js';
+import { AdaptyCommand, csvFlag, filterFlags, groupByFlag, groupingParams, periodFlags, queryParams, renewalPeriodFlags, revenueBasisFlag, } from '../../base/adapty/index.js';
+import { appIdFlag } from '../../input/app.js';
+import { analyticsView, ltvTable } from '../../views/analytics/human.js';
+import { csvNotice } from '../../views/analytics/segments.js';
+export default class AnalyticsLtv extends AdaptyCommand {
+    static description = 'Read the LTV of an app: the revenue per paying user after each renewal (or day), '
+        + 'per group, the total first (no compared period)';
+    static examples = [
+        '<%= config.bin %> analytics ltv --app APP_UUID --date-from 2026-07-01 --date-to 2026-09-30',
+        '<%= config.bin %> analytics ltv --app APP_UUID --date-from 2026-07-01 --date-to 2026-09-30 --revenue-basis net --period-type days --renewal-days 7,30,90 --csv',
+    ];
+    static flags = {
+        ...appIdFlag,
+        ...periodFlags,
+        ...groupByFlag,
+        ...filterFlags,
+        ...revenueBasisFlag,
+        ...renewalPeriodFlags,
+        ...csvFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsLtv);
+        const input = {
+            ...queryParams(flags),
+            ...groupingParams(flags),
+            periodType: flags['period-type'],
+            renewalDays: flags['renewal-days'],
+            revenueBasis: flags['revenue-basis'],
+        };
+        // Before this.adapty: bad input is exit 2 even without a token
+        assertValid(validateLtv(input));
+        const answer = await this.adapty.analytics.ltv(input);
+        this.render(answer, analyticsView(flags.csv, ltvTable));
+        // Beside a CSV of a period without data, its summary; an empty text otherwise
+        process.stderr.write(csvNotice(answer, flags.csv));
+        return answer;
+    }
+}

package/dist/cli/commands/analytics/retention.d.ts

@@ -0,0 +1,17 @@
+import { AdaptyCommand } from '../../base/adapty/index.js';
+import type { RetentionResponse } from '../../../sdk/adapty/index.js';
+export default class AnalyticsRetention extends AdaptyCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        csv: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'use-trial': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        filter: import("@oclif/core/interfaces").OptionFlag<import("../../../sdk/adapty/index.js").AnalyticsFilter[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'group-by': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'date-from': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'date-to': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<RetentionResponse>;
+}

package/dist/cli/commands/analytics/retention.js

@@ -0,0 +1,41 @@
+import { Flags } from '@oclif/core';
+import { validateRetention } from '../../../sdk/adapty/index.js';
+import { assertValid } from '../../../sdk/core/validation.js';
+import { AdaptyCommand, csvFlag, filterFlags, groupByFlag, groupingParams, periodFlags, queryParams, } from '../../base/adapty/index.js';
+import { appIdFlag } from '../../input/app.js';
+import { analyticsView, retentionTable } from '../../views/analytics/human.js';
+import { csvNotice } from '../../views/analytics/segments.js';
+export default class AnalyticsRetention extends AdaptyCommand {
+    static description = 'Read the retention of an app: the subscribers left in each period, per group, '
+        + 'the total first (no compared period)';
+    static examples = [
+        '<%= config.bin %> analytics retention --app APP_UUID --date-from 2026-07-01 --date-to 2026-09-30',
+        '<%= config.bin %> analytics retention --app APP_UUID --date-from 2026-07-01 --date-to 2026-09-30 --group-by country --use-trial --csv',
+    ];
+    static flags = {
+        ...appIdFlag,
+        ...periodFlags,
+        ...groupByFlag,
+        ...filterFlags,
+        'use-trial': Flags.boolean({
+            description: 'Count from the trial, not from the first paid period',
+        }),
+        ...csvFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsRetention);
+        const input = {
+            ...queryParams(flags),
+            ...groupingParams(flags),
+            // Sent only when given: the backend default (false) applies otherwise, and meta.query says so
+            useTrial: flags['use-trial'] ? true : undefined,
+        };
+        // Before this.adapty: bad input is exit 2 even without a token
+        assertValid(validateRetention(input));
+        const answer = await this.adapty.analytics.retention(input);
+        this.render(answer, analyticsView(flags.csv, retentionTable));
+        // Beside a CSV of a period without data, its summary; an empty text otherwise
+        process.stderr.write(csvNotice(answer, flags.csv));
+        return answer;
+    }
+}

package/dist/cli/commands/analytics/values.d.ts

@@ -0,0 +1,11 @@
+import { AdaptyCommand } from '../../base/adapty/index.js';
+import type { FilterValuesResponse } from '../../../sdk/adapty/index.js';
+export default class AnalyticsValues extends AdaptyCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dimension: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<FilterValuesResponse>;
+}

package/dist/cli/commands/analytics/values.js

@@ -0,0 +1,33 @@
+import { Flags } from '@oclif/core';
+import { validateFilterValues } from '../../../sdk/adapty/index.js';
+import { assertValid } from '../../../sdk/core/validation.js';
+import { AdaptyCommand } from '../../base/adapty/index.js';
+import { appIdFlag } from '../../input/app.js';
+/** The value first, as `--filter <dimension>=<value>` takes it; an empty value is shown as `""`. */
+const describeValue = (item) => `${item.value === '' ? '""' : item.value}: ${item.label}${item.group === null ? '' : ` (${item.group})`}`;
+const renderValues = ({ data, meta }) => (data.length === 0
+    ? `No ${meta.dimension} values for this app.`
+    : data.map(item => describeValue(item)).join('\n'));
+export default class AnalyticsValues extends AdaptyCommand {
+    static description = 'List the values one analytics filter takes for an app: what --filter accepts';
+    static examples = [
+        '<%= config.bin %> analytics values --app APP_UUID --dimension country',
+        '<%= config.bin %> analytics values --app APP_UUID --dimension store_product_id --json',
+    ];
+    static flags = {
+        ...appIdFlag,
+        dimension: Flags.string({
+            description: 'A filter dimension, as `adapty analytics catalog` lists it under Dimensions',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsValues);
+        const input = { appId: flags.app, dimension: flags.dimension };
+        // Before this.adapty: bad input is exit 2 even without a token
+        assertValid(validateFilterValues(input));
+        const values = await this.adapty.analytics.values(input);
+        this.render(values, renderValues);
+        return values;
+    }
+}

package/dist/cli/commands/attribution/report/command.js

@@ -4,20 +4,15 @@ import { assertValid } from '../../../../sdk/core/validation.js';
 import { AttributionCommand, periodFlags, periodParams, revenueBasisFlag } from '../../../base/attribution/index.js';
 import { usageError } from '../../../errors.js';
 import { appIdFlag } from '../../../input/app.js';
+import { splitFilter } from '../../../input/filter.js';
 import { renderReport } from './lib/render.js';
-/** A comma not preceded by a backslash: `\,` keeps a comma inside a value, as oclif's own delimiter does. */
-const VALUE_SEPARATOR = /(?<!\\),/;
-/** `dimension=value[,value]`: one value filters by equality, several by any of them. */
+/** `dimension=value[,value]`: one value filters by equality, several by any; values trimmed, empties dropped. */
 const parseFilter = (input) => {
-    const separator = input.indexOf('=');
-    const dimension = separator === -1 ? '' : input.slice(0, separator).trim();
-    const values = separator === -1
-        ? []
-        : input.slice(separator + 1).split(VALUE_SEPARATOR).map(value => value.replaceAll('\\,', ',').trim())
-            .filter(value => value !== '');
-    return dimension === '' || values.length === 0
+    const filter = splitFilter(input);
+    const values = filter?.values.map(value => value.trim()).filter(value => value !== '') ?? [];
+    return filter === undefined || values.length === 0
         ? Promise.reject(usageError(`Expected dimension=value[,value], got "${input}".`))
-        : Promise.resolve({ dimension, values });
+        : Promise.resolve({ dimension: filter.dimension, values });
 };
 const isDirection = (value) => sortDirections.includes(value);
 /** `field[:asc|desc]`, ascending when the direction is left out. */

package/dist/cli/errors.js

@@ -88,7 +88,14 @@ export const describeCleanupFailures = (files, results) => {
 };
 /** Issue.path is a camelCase sdk field; the user typed a kebab-case flag. */
 const flagName = (path) => `--${path.replace(/[A-Z]/g, char => `-${char.toLowerCase()}`)}`;
-const describeIssue = (issue) => (issue.path === undefined ? issue.message : `${flagName(issue.path)}: ${issue.message}`);
+/**
+ * A rule names another input field as `{fieldName}` and lists it in `fields`: the user reads the flag they would
+ * type. Only the listed names are written, so other braces in a message stay as they are.
+ */
+const describeIssue = (issue) => {
+    const message = (issue.fields ?? []).reduce((text, field) => text.replaceAll(`{${field}}`, flagName(field)), issue.message);
+    return issue.path === undefined ? message : `${flagName(issue.path)}: ${message}`;
+};
 /**
  * The one place where an sdk error gets a human text and an exit code. No default in the switch:
  * a new kind fails to compile until it is mapped here.

package/dist/cli/input/filter.d.ts

@@ -0,0 +1,11 @@
+/** One `--filter`: a dimension and the values it may take (one value is equality, several any of them). */
+export type DimensionFilter = {
+    dimension: string;
+    values: string[];
+};
+/**
+ * `dimension=value[,value]` split as written: the dimension before the first `=`, trimmed; every value after it
+ * as typed, `\,` turned into a comma. Undefined without `=` or without a dimension. What a product does with
+ * spaces and empty values is its own rule, so its flag parser decides that.
+ */
+export declare const splitFilter: (input: string) => DimensionFilter | undefined;

package/dist/cli/input/filter.js

@@ -0,0 +1,16 @@
+/** A comma not preceded by a backslash: `\,` keeps a comma inside a value, as oclif's own delimiter does. */
+const VALUE_SEPARATOR = /(?<!\\),/;
+/**
+ * `dimension=value[,value]` split as written: the dimension before the first `=`, trimmed; every value after it
+ * as typed, `\,` turned into a comma. Undefined without `=` or without a dimension. What a product does with
+ * spaces and empty values is its own rule, so its flag parser decides that.
+ */
+export const splitFilter = (input) => {
+    const separator = input.indexOf('=');
+    const dimension = separator === -1 ? '' : input.slice(0, separator).trim();
+    if (dimension === '') {
+        return undefined;
+    }
+    const values = input.slice(separator + 1).split(VALUE_SEPARATOR).map(value => value.replaceAll('\\,', ','));
+    return { dimension, values };
+};

package/dist/cli/input/period.d.ts

@@ -0,0 +1,10 @@
+/** The shape only: whether the day exists and the order of the two are sdk rules. */
+export declare const dateParser: (input: string) => Promise<string>;
+/**
+ * An inclusive day range, both ends required. `zone` completes the help text: which time zone the days are in,
+ * the one thing the products say differently.
+ */
+export declare const dayRangeFlags: (zone: string) => {
+    'date-from': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    'date-to': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+};

package/dist/cli/input/period.js

@@ -0,0 +1,23 @@
+import { Flags } from '@oclif/core';
+import { ISO_DATE } from '../../sdk/core/dates.js';
+import { usageError } from '../errors.js';
+/** The shape only: whether the day exists and the order of the two are sdk rules. */
+export const dateParser = (input) => (ISO_DATE.test(input)
+    ? Promise.resolve(input)
+    : Promise.reject(usageError('Dates must be written as YYYY-MM-DD.')));
+/**
+ * An inclusive day range, both ends required. `zone` completes the help text: which time zone the days are in,
+ * the one thing the products say differently.
+ */
+export const dayRangeFlags = (zone) => ({
+    'date-from': Flags.string({
+        description: `First day of the period, inclusive (YYYY-MM-DD, ${zone})`,
+        parse: dateParser,
+        required: true,
+    }),
+    'date-to': Flags.string({
+        description: `Last day of the period, inclusive (YYYY-MM-DD, ${zone})`,
+        parse: dateParser,
+        required: true,
+    }),
+});

package/dist/cli/views/analytics/csv.d.ts

@@ -0,0 +1,3 @@
+/** What a CSV cell can hold: the scalar values of an API answer. */
+export type Cell = boolean | null | number | string | undefined;
+export declare const csvLine: (cells: readonly Cell[]) => string;

package/dist/cli/views/analytics/csv.js

@@ -0,0 +1,16 @@
+/**
+ * RFC 4180: a field with a comma, a double quote or a line break goes in double quotes, and a quote inside is
+ * doubled. A missing value (null) is an empty cell, so it never reads as 0; an empty text (a group key, for
+ * example) is `""`, so it never reads as a missing one.
+ */
+const csvCell = (value) => {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (value === '') {
+        return '""';
+    }
+    const text = String(value);
+    return /[",\n\r]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+};
+export const csvLine = (cells) => cells.map(cell => csvCell(cell)).join(',');

package/dist/cli/views/analytics/human.d.ts

@@ -0,0 +1,41 @@
+import type { AnalyticsAnswer } from './segments.js';
+/**
+ * The human view of the six analytics operations: a short table, one row per group (the total first), the main
+ * numbers of the group and one column per point (a date, a funnel step, a period). The resolved query gives the
+ * heading. Where an operation has more fields than one table holds, a line under it says that `--json` and
+ * `--csv` give every field.
+ */
+type Query = Record<string, unknown>;
+/** How a number reads: money with 2 decimals, any other number as the API gives it, null as `—`. */
+type Format = (value: unknown) => string;
+/** One number of a group: its header and the segment field it shows. */
+type Column = {
+    field: string;
+    format: Format;
+    header: string;
+};
+export type HumanTable = {
+    /** The numbers of a group after its title, the main value first. */
+    columns: (query: Query) => Column[];
+    /** The fields the table leaves out; none when it shows every number of the answer. */
+    omitted?: string;
+    /** How the value of a point reads. */
+    points: (query: Query) => Format;
+    /** What the answer is, from the resolved query: the operation, then its options. */
+    title: (query: Query) => (string | undefined)[];
+};
+export declare const chartTable: HumanTable;
+export declare const conversionTable: HumanTable;
+export declare const funnelTable: HumanTable;
+export declare const retentionTable: HumanTable;
+export declare const ltvTable: HumanTable;
+export declare const cohortTable: HumanTable;
+/**
+ * The heading (what, by which grouping; the period, its time zone and filters), then the table of the asked
+ * period and, when there is one, of the compared period. A period without groups: `No data for this period.` and
+ * the summary of that period, every field, null as `—`.
+ */
+export declare const humanView: (spec: HumanTable) => (answer: AnalyticsAnswer) => string;
+/** The view of a data command: the CSV with `--csv`, else the human table (`--json` prints no view at all). */
+export declare const analyticsView: (csv: boolean, spec: HumanTable) => (answer: AnalyticsAnswer) => string;
+export {};

package/dist/cli/views/analytics/human.js

@@ -0,0 +1,134 @@
+import { formatValue, line, NO_DATA, NO_VALUE, pointId, pointLabel, renderCsv, sectionsOf, } from './segments.js';
+const asGiven = (value) => {
+    if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return NO_VALUE;
+};
+const money = value => (typeof value === 'number' ? value.toFixed(2) : asGiven(value));
+const text = (value) => (typeof value === 'string' && value !== '' ? value : undefined);
+const groupedBy = (query) => {
+    const segmentation = text(query.segmentation);
+    return segmentation === undefined ? undefined : `by ${segmentation}`;
+};
+const perPeriod = (query) => {
+    if (query.period_type === 'renewals') {
+        return 'per renewal';
+    }
+    return query.period_type === 'days' ? 'per day' : undefined;
+};
+const isMoneyChart = (query) => text(query.revenue_basis) !== undefined;
+export const chartTable = {
+    columns: query => [{ field: 'value', format: isMoneyChart(query) ? money : asGiven, header: 'Total' }],
+    points: query => (isMoneyChart(query) ? money : asGiven),
+    title: query => [['Chart', text(query.chart_id)].filter(part => part !== undefined).join(' '), text(query.revenue_basis), groupedBy(query)],
+};
+export const conversionTable = {
+    columns: () => [
+        { field: 'value', format: asGiven, header: 'Conversion %' },
+        { field: 'value_from', format: asGiven, header: 'From' },
+        { field: 'value_to', format: asGiven, header: 'To' },
+    ],
+    omitted: 'the counts of each point (value_from, value_to, value_from_unfinished, has_unfinished)',
+    points: () => asGiven,
+    title: query => [['Conversion', text(query.conversion_id)].filter(part => part !== undefined).join(' '), groupedBy(query)],
+};
+export const funnelTable = {
+    columns: () => [{ field: 'value', format: asGiven, header: 'Installs' }],
+    omitted: 'the share of each step, the change to the next step, churn reasons and parts',
+    points: () => asGiven,
+    title: query => ['Funnel', groupedBy(query)],
+};
+export const retentionTable = {
+    columns: () => [{ field: 'value', format: asGiven, header: 'Subscribers' }],
+    omitted: 'the share of each period (value_relative)',
+    points: () => asGiven,
+    title: query => ['Retention', query.use_trial === true ? 'from the trial' : undefined, groupedBy(query)],
+};
+export const ltvTable = {
+    columns: () => [
+        { field: 'value', format: money, header: 'LTV' },
+        { field: 'cohort_size', format: asGiven, header: 'Cohort size' },
+    ],
+    points: () => money,
+    title: query => ['LTV', text(query.revenue_basis), perPeriod(query), groupedBy(query)],
+};
+export const cohortTable = {
+    columns: () => [
+        { field: 'value', format: money, header: 'Revenue' },
+        { field: 'installs', format: asGiven, header: 'Installs' },
+        { field: 'subscribers', format: asGiven, header: 'Subscribers' },
+    ],
+    omitted: 'revenue, ARPU, ARPPU and ARPAS on each basis, subscriptions, the shares of each period, predictions',
+    points: () => money,
+    title: query => ['Cohorts', text(query.revenue_basis), perPeriod(query)],
+};
+const range = (dates) => (Array.isArray(dates) && dates.length > 0 ? dates.join(' – ') : undefined);
+const PERIOD_KEYS = new Set(['compare_date', 'date']);
+/** The filters besides the period, as `--filter` takes them. */
+const filtersOf = (filters) => {
+    const given = Object.entries(filters).filter(([dimension]) => !PERIOD_KEYS.has(dimension))
+        .map(([dimension, values]) => `${dimension}=${values.map(value => value.replaceAll(',', String.raw `\,`)).join(',')}`);
+    return given.length === 0 ? undefined : `filters ${given.join(' ')}`;
+};
+const TIMEZONE_SOURCES = { app: 'from the app', request: 'from --timezone' };
+/** The period, the length of one point, the time zone and where it comes from, and the filters. */
+const periodLine = (query) => {
+    const filters = (query.filters ?? {});
+    const source = TIMEZONE_SOURCES[String(query.timezone_source)];
+    const zone = text(query.timezone);
+    const timezone = zone === undefined ? undefined : `time zone ${zone}${source === undefined ? '' : ` (${source})`}`;
+    return [range(filters.date), text(query.period_unit), timezone, filtersOf(filters)]
+        .filter(part => part !== undefined).join(', ');
+};
+/** Rows of cells, the first column left-aligned, the numbers right-aligned, two spaces between. */
+const table = (rows) => {
+    const widths = rows[0]?.map((_, column) => Math.max(...rows.map(row => row[column]?.length ?? 0))) ?? [];
+    return rows.map(row => row.map((cell, column) => (column === 0
+        ? cell.padEnd(widths[column] ?? 0)
+        : cell.padStart(widths[column] ?? 0))).join('  ').trimEnd()).join('\n');
+};
+const fieldOf = (value, name) => value[name];
+/** One row per group, the total first (as `sectionsOf` orders them), then one column per point in first-seen order. */
+const tableOf = (spec, query, segments) => {
+    const columns = spec.columns(query);
+    const format = spec.points(query);
+    const points = new Map();
+    for (const point of segments.flatMap(segment => segment.values)) {
+        if (!points.has(pointId(point))) {
+            points.set(pointId(point), pointLabel(point));
+        }
+    }
+    const rows = segments.map(segment => [
+        formatValue(segment.title),
+        ...columns.map(column => column.format(fieldOf(segment, column.field))),
+        ...[...points.keys()].map(id => format(fieldOf(segment.values.find(point => pointId(point) === id) ?? {}, 'value'))),
+    ]);
+    return table([['', ...columns.map(column => column.header), ...points.values()], ...rows]);
+};
+const comparedHeading = (query) => {
+    const dates = range((query.filters ?? {}).compare_date);
+    return dates === undefined ? 'Compared period' : `Compared period: ${dates}`;
+};
+/**
+ * The heading (what, by which grouping; the period, its time zone and filters), then the table of the asked
+ * period and, when there is one, of the compared period. A period without groups: `No data for this period.` and
+ * the summary of that period, every field, null as `—`.
+ */
+export const humanView = (spec) => (answer) => {
+    const query = answer.meta.query;
+    const sections = sectionsOf(answer);
+    const bodies = sections.map((section) => {
+        const heading = section.period === 'compare' ? [comparedHeading(query)] : [];
+        if (section.segments.length === 0) {
+            return [...heading, NO_DATA, ...section.summary.map(field => line(field))].join('\n');
+        }
+        return [...heading, tableOf(spec, query, section.segments)].join('\n');
+    });
+    const hasTable = sections.some(section => section.segments.length > 0);
+    const more = spec.omitted !== undefined && hasTable ? [`--json and --csv give every field: ${spec.omitted}.`] : [];
+    const title = spec.title(query).filter(part => part !== undefined).join(', ');
+    return [[title, periodLine(query)].join('\n'), ...bodies, ...more].join('\n\n');
+};
+/** The view of a data command: the CSV with `--csv`, else the human table (`--json` prints no view at all). */
+export const analyticsView = (csv, spec) => (answer) => (csv ? renderCsv(answer) : humanView(spec)(answer));

package/dist/cli/views/analytics/segments.d.ts

@@ -0,0 +1,68 @@
+import type { Cell } from './csv.js';
+import type { AnalyticsSegment } from '../../../sdk/adapty/index.js';
+/**
+ * The CSV of the six analytics operations and the summary of a period, made from the answer itself: every field
+ * the API gives is printed, under the name it has in --json, so a field the backend adds is never dropped. A nested
+ * field has a dotted name (`revenue.gross`, `following_changes.value`), a list item its index (`parts[0].value`).
+ * The human table, which shows the main fields only, is in `human.ts`.
+ */
+export type Segment = AnalyticsSegment & {
+    values: readonly object[];
+};
+type Segments = {
+    segments: readonly Segment[];
+};
+/** What every analytics answer has; `compare` only a chart and a conversion, null without a compared period. */
+export type AnalyticsAnswer = {
+    data: Segments & {
+        compare?: null | Segments;
+    };
+    meta: {
+        query: object;
+    };
+};
+type Field = readonly [name: string, value: Cell];
+/** `main` is the asked period; `compare` the compared one. */
+type Section = {
+    period: 'compare' | 'main';
+    segments: readonly Segment[];
+    /** The numbers of the whole period and, for the asked one, the resolved query and the other `meta` fields. */
+    summary: Field[];
+};
+/** A number the backend does not have is null, and printing it as 0 would be a lie. */
+export declare const NO_VALUE = "\u2014";
+export declare const NO_DATA = "No data for this period.";
+/** An empty text (the key of a "No Data" group, for example) is shown as `""`, so it never reads as a missing value. */
+export declare const formatValue: (value: Cell) => string;
+/** A point is found by its `x`. */
+export declare const pointId: (point: object) => string;
+/**
+ * How the human view names a point: its `x`, and for a funnel step or a retention period also its title, the
+ * number once (`-2 Install`, `1 Paid`, `2 Period`).
+ */
+export declare const pointLabel: (point: object) => string;
+/**
+ * The summary of the asked period: every field of `data` besides the segments, every field of `meta.query` (the
+ * resolved query: the time zone, the filters, the defaults) and every other field of `meta` (a conversion's
+ * `recommended_period`), named as in their object. Of a compared period: the fields of `data.compare`.
+ */
+export declare const sectionsOf: (answer: AnalyticsAnswer) => Section[];
+export declare const line: ([name, value]: Field) => string;
+/**
+ * The CSV view, made from the API answer: a header line, then one row per group, the total first (`is_total`
+ * true; its `key` cell is empty, as is the cell of a group whose raw key is null; a key `""` is written `""`).
+ * Columns: `key`, `title`, `is_total`; the numbers of the group in the asked period, then each point's `value`
+ * (named by its `x`) and its other fields as `<x>.<field>` (a funnel step's or retention period's title as
+ * `<x>.title`); the same for the compared period under `compare.`; then every other field of the answer under its
+ * JSON path (`data.value`, `data.compare.value`, `meta.query.timezone`, `meta.query.revenue_basis`, ...), the same
+ * on every row. A group of one period only has empty cells in the other. A null value is an empty cell. No groups:
+ * the header line alone.
+ */
+export declare const renderCsv: (answer: AnalyticsAnswer) => string;
+/**
+ * What a data command writes to stderr: with `--csv`, when the asked period has no segments, `No data for this
+ * period.` and the summary of each period, as the human view shows them (the CSV is then its header alone, or the
+ * groups of the compared period); else nothing, an empty text.
+ */
+export declare const csvNotice: (answer: AnalyticsAnswer, csv: boolean) => string;
+export {};